drivers/media/rc/sir_ir.c

   1 /*
   2  * IR SIR driver, (C) 2000 Milan Pikula <www@fornax.sk>
   3  *
   4  * sir_ir - Device driver for use with SIR (serial infra red)
   5  * mode of IrDA on many notebooks.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/module.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/kernel.h>
  18 #include <linux/serial_reg.h>
  19 #include <linux/ktime.h>
  20 #include <linux/delay.h>
  21 #include <linux/platform_device.h>
  22
  23 #include <media/rc-core.h>
  24
  25 /* SECTION: Definitions */
  26 #define PULSE '['
  27
  28 /* 9bit * 1s/115200bit in milli seconds = 78.125ms*/
  29 #define TIME_CONST (9000000ul / 115200ul)
  30
  31 /* timeout for sequences in jiffies (=5/100s), must be longer than TIME_CONST */
  32 #define SIR_TIMEOUT     (HZ * 5 / 100)
  33
  34 /* onboard sir ports are typically com3 */
  35 static int io = 0x3e8;
  36 static int irq = 4;
  37 static int threshold = 3;
  38
  39 static DEFINE_SPINLOCK(timer_lock);
  40 static struct timer_list timerlist;
  41 /* time of last signal change detected */
  42 static ktime_t last;
  43 /* time of last UART data ready interrupt */
  44 static ktime_t last_intr_time;
  45 static int last_value;
  46 static struct rc_dev *rcdev;
  47
  48 static struct platform_device *sir_ir_dev;
  49
  50 static DEFINE_SPINLOCK(hardware_lock);
  51
  52 /* SECTION: Prototypes */
  53
  54 /* Communication with user-space */
  55 static void add_read_queue(int flag, unsigned long val);
  56 static int init_chrdev(void);
  57 /* Hardware */
  58 static irqreturn_t sir_interrupt(int irq, void *dev_id);
  59 static void send_space(unsigned long len);
  60 static void send_pulse(unsigned long len);
  61 static int init_hardware(void);
  62 static void drop_hardware(void);
  63 /* Initialisation */
  64 static int init_port(void);
  65 static void drop_port(void);
  66
  67 static inline unsigned int sinp(int offset)
  68 {
  69         return inb(io + offset);
  70 }
  71
  72 static inline void soutp(int offset, int value)
  73 {
  74         outb(value, io + offset);
  75 }
  76
  77 /* SECTION: Communication with user-space */
  78 static int sir_tx_ir(struct rc_dev *dev, unsigned int *tx_buf,
  79                      unsigned int count)
  80 {
  81         unsigned long flags;
  82         int i;
  83
  84         local_irq_save(flags);
  85         for (i = 0; i < count;) {
  86                 if (tx_buf[i])
  87                         send_pulse(tx_buf[i]);
  88                 i++;
  89                 if (i >= count)
  90                         break;
  91                 if (tx_buf[i])
  92                         send_space(tx_buf[i]);
  93                 i++;
  94         }
  95         local_irq_restore(flags);
  96
  97         return count;
  98 }
  99
 100 static void add_read_queue(int flag, unsigned long val)
 101 {
 102         DEFINE_IR_RAW_EVENT(ev);
 103
 104         pr_debug("add flag %d with val %lu\n", flag, val);
 105
 106         /*
 107          * statistically, pulses are ~TIME_CONST/2 too long. we could
 108          * maybe make this more exact, but this is good enough
 109          */
 110         if (flag) {
 111                 /* pulse */
 112                 if (val > TIME_CONST / 2)
 113                         val -= TIME_CONST / 2;
 114                 else /* should not ever happen */
 115                         val = 1;
 116                 ev.pulse = true;
 117         } else {
 118                 val += TIME_CONST / 2;
 119         }
 120         ev.duration = US_TO_NS(val);
 121
 122         ir_raw_event_store_with_filter(rcdev, &ev);
 123 }
 124
 125 static int init_chrdev(void)
 126 {
 127         rcdev = devm_rc_allocate_device(&sir_ir_dev->dev, RC_DRIVER_IR_RAW);
 128         if (!rcdev)
 129                 return -ENOMEM;
 130
 131         rcdev->input_name = "SIR IrDA port";
 132         rcdev->input_phys = KBUILD_MODNAME "/input0";
 133         rcdev->input_id.bustype = BUS_HOST;
 134         rcdev->input_id.vendor = 0x0001;
 135         rcdev->input_id.product = 0x0001;
 136         rcdev->input_id.version = 0x0100;
 137         rcdev->tx_ir = sir_tx_ir;
 138         rcdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
 139         rcdev->driver_name = KBUILD_MODNAME;
 140         rcdev->map_name = RC_MAP_RC6_MCE;
 141         rcdev->timeout = IR_DEFAULT_TIMEOUT;
 142         rcdev->dev.parent = &sir_ir_dev->dev;
 143
 144         return devm_rc_register_device(&sir_ir_dev->dev, rcdev);
 145 }
 146
 147 /* SECTION: Hardware */
 148 static void sir_timeout(unsigned long data)
 149 {
 150         /*
 151          * if last received signal was a pulse, but receiving stopped
 152          * within the 9 bit frame, we need to finish this pulse and
 153          * simulate a signal change to from pulse to space. Otherwise
 154          * upper layers will receive two sequences next time.
 155          */
 156
 157         unsigned long flags;
 158         unsigned long pulse_end;
 159
 160         /* avoid interference with interrupt */
 161         spin_lock_irqsave(&timer_lock, flags);
 162         if (last_value) {
 163                 /* clear unread bits in UART and restart */
 164                 outb(UART_FCR_CLEAR_RCVR, io + UART_FCR);
 165                 /* determine 'virtual' pulse end: */
 166                 pulse_end = min_t(unsigned long,
 167                                   ktime_us_delta(last, last_intr_time),
 168                                   IR_MAX_DURATION);
 169                 dev_dbg(&sir_ir_dev->dev, "timeout add %d for %lu usec\n",
 170                         last_value, pulse_end);
 171                 add_read_queue(last_value, pulse_end);
 172                 last_value = 0;
 173                 last = last_intr_time;
 174         }
 175         spin_unlock_irqrestore(&timer_lock, flags);
 176         ir_raw_event_handle(rcdev);
 177 }
 178
 179 static irqreturn_t sir_interrupt(int irq, void *dev_id)
 180 {
 181         unsigned char data;
 182         ktime_t curr_time;
 183         static unsigned long delt;
 184         unsigned long deltintr;
 185         unsigned long flags;
 186         int counter = 0;
 187         int iir, lsr;
 188
 189         while ((iir = inb(io + UART_IIR) & UART_IIR_ID)) {
 190                 if (++counter > 256) {
 191                         dev_err(&sir_ir_dev->dev, "Trapped in interrupt");
 192                         break;
 193                 }
 194
 195                 switch (iir & UART_IIR_ID) { /* FIXME toto treba preriedit */
 196                 case UART_IIR_MSI:
 197                         (void)inb(io + UART_MSR);
 198                         break;
 199                 case UART_IIR_RLSI:
 200                 case UART_IIR_THRI:
 201                         (void)inb(io + UART_LSR);
 202                         break;
 203                 case UART_IIR_RDI:
 204                         /* avoid interference with timer */
 205                         spin_lock_irqsave(&timer_lock, flags);
 206                         do {
 207                                 del_timer(&timerlist);
 208                                 data = inb(io + UART_RX);
 209                                 curr_time = ktime_get();
 210                                 delt = min_t(unsigned long,
 211                                              ktime_us_delta(last, curr_time),
 212                                              IR_MAX_DURATION);
 213                                 deltintr = min_t(unsigned long,
 214                                                  ktime_us_delta(last_intr_time,
 215                                                                 curr_time),
 216                                                  IR_MAX_DURATION);
 217                                 dev_dbg(&sir_ir_dev->dev, "t %lu, d %d\n",
 218                                         deltintr, (int)data);
 219                                 /*
 220                                  * if nothing came in last X cycles,
 221                                  * it was gap
 222                                  */
 223                                 if (deltintr > TIME_CONST * threshold) {
 224                                         if (last_value) {
 225                                                 dev_dbg(&sir_ir_dev->dev, "GAP\n");
 226                                                 /* simulate signal change */
 227                                                 add_read_queue(last_value,
 228                                                                delt -
 229                                                                deltintr);
 230                                                 last_value = 0;
 231                                                 last = last_intr_time;
 232                                                 delt = deltintr;
 233                                         }
 234                                 }
 235                                 data = 1;
 236                                 if (data ^ last_value) {
 237                                         /*
 238                                          * deltintr > 2*TIME_CONST, remember?
 239                                          * the other case is timeout
 240                                          */
 241                                         add_read_queue(last_value,
 242                                                        delt - TIME_CONST);
 243                                         last_value = data;
 244                                         last = curr_time;
 245                                         last = ktime_sub_us(last,
 246                                                             TIME_CONST);
 247                                 }
 248                                 last_intr_time = curr_time;
 249                                 if (data) {
 250                                         /*
 251                                          * start timer for end of
 252                                          * sequence detection
 253                                          */
 254                                         timerlist.expires = jiffies +
 255                                                                 SIR_TIMEOUT;
 256                                         add_timer(&timerlist);
 257                                 }
 258
 259                                 lsr = inb(io + UART_LSR);
 260                         } while (lsr & UART_LSR_DR); /* data ready */
 261                         spin_unlock_irqrestore(&timer_lock, flags);
 262                         break;
 263                 default:
 264                         break;
 265                 }
 266         }
 267         ir_raw_event_handle(rcdev);
 268         return IRQ_RETVAL(IRQ_HANDLED);
 269 }
 270
 271 static void send_space(unsigned long len)
 272 {
 273         usleep_range(len, len + 25);
 274 }
 275
 276 static void send_pulse(unsigned long len)
 277 {
 278         long bytes_out = len / TIME_CONST;
 279
 280         if (bytes_out == 0)
 281                 bytes_out++;
 282
 283         while (bytes_out--) {
 284                 outb(PULSE, io + UART_TX);
 285                 /* FIXME treba seriozne cakanie z char/serial.c */
 286                 while (!(inb(io + UART_LSR) & UART_LSR_THRE))
 287                         ;
 288         }
 289 }
 290
 291 static int init_hardware(void)
 292 {
 293         unsigned long flags;
 294
 295         spin_lock_irqsave(&hardware_lock, flags);
 296         /* reset UART */
 297         outb(0, io + UART_MCR);
 298         outb(0, io + UART_IER);
 299         /* init UART */
 300         /* set DLAB, speed = 115200 */
 301         outb(UART_LCR_DLAB | UART_LCR_WLEN7, io + UART_LCR);
 302         outb(1, io + UART_DLL); outb(0, io + UART_DLM);
 303         /* 7N1+start = 9 bits at 115200 ~ 3 bits at 44000 */
 304         outb(UART_LCR_WLEN7, io + UART_LCR);
 305         /* FIFO operation */
 306         outb(UART_FCR_ENABLE_FIFO, io + UART_FCR);
 307         /* interrupts */
 308         /* outb(UART_IER_RLSI|UART_IER_RDI|UART_IER_THRI, io + UART_IER); */
 309         outb(UART_IER_RDI, io + UART_IER);
 310         /* turn on UART */
 311         outb(UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2, io + UART_MCR);
 312         spin_unlock_irqrestore(&hardware_lock, flags);
 313         return 0;
 314 }
 315
 316 static void drop_hardware(void)
 317 {
 318         unsigned long flags;
 319
 320         spin_lock_irqsave(&hardware_lock, flags);
 321
 322         /* turn off interrupts */
 323         outb(0, io + UART_IER);
 324
 325         spin_unlock_irqrestore(&hardware_lock, flags);
 326 }
 327
 328 /* SECTION: Initialisation */
 329
 330 static int init_port(void)
 331 {
 332         int retval;
 333
 334         setup_timer(&timerlist, sir_timeout, 0);
 335
 336         /* get I/O port access and IRQ line */
 337         if (!request_region(io, 8, KBUILD_MODNAME)) {
 338                 pr_err("i/o port 0x%.4x already in use.\n", io);
 339                 return -EBUSY;
 340         }
 341         retval = request_irq(irq, sir_interrupt, 0,
 342                              KBUILD_MODNAME, NULL);
 343         if (retval < 0) {
 344                 release_region(io, 8);
 345                 pr_err("IRQ %d already in use.\n", irq);
 346                 return retval;
 347         }
 348         pr_info("I/O port 0x%.4x, IRQ %d.\n", io, irq);
 349
 350         return 0;
 351 }
 352
 353 static void drop_port(void)
 354 {
 355         free_irq(irq, NULL);
 356         del_timer_sync(&timerlist);
 357         release_region(io, 8);
 358 }
 359
 360 static int init_sir_ir(void)
 361 {
 362         int retval;
 363
 364         retval = init_port();
 365         if (retval < 0)
 366                 return retval;
 367         init_hardware();
 368         return 0;
 369 }
 370
 371 static int sir_ir_probe(struct platform_device *dev)
 372 {
 373         int retval;
 374
 375         retval = init_chrdev();
 376         if (retval < 0)
 377                 return retval;
 378
 379         return init_sir_ir();
 380 }
 381
 382 static int sir_ir_remove(struct platform_device *dev)
 383 {
 384         return 0;
 385 }
 386
 387 static struct platform_driver sir_ir_driver = {
 388         .probe          = sir_ir_probe,
 389         .remove         = sir_ir_remove,
 390         .driver         = {
 391                 .name   = "sir_ir",
 392         },
 393 };
 394
 395 static int __init sir_ir_init(void)
 396 {
 397         int retval;
 398
 399         retval = platform_driver_register(&sir_ir_driver);
 400         if (retval)
 401                 return retval;
 402
 403         sir_ir_dev = platform_device_alloc("sir_ir", 0);
 404         if (!sir_ir_dev) {
 405                 retval = -ENOMEM;
 406                 goto pdev_alloc_fail;
 407         }
 408
 409         retval = platform_device_add(sir_ir_dev);
 410         if (retval)
 411                 goto pdev_add_fail;
 412
 413         return 0;
 414
 415 pdev_add_fail:
 416         platform_device_put(sir_ir_dev);
 417 pdev_alloc_fail:
 418         platform_driver_unregister(&sir_ir_driver);
 419         return retval;
 420 }
 421
 422 static void __exit sir_ir_exit(void)
 423 {
 424         drop_hardware();
 425         drop_port();
 426         platform_device_unregister(sir_ir_dev);
 427         platform_driver_unregister(&sir_ir_driver);
 428 }
 429
 430 module_init(sir_ir_init);
 431 module_exit(sir_ir_exit);
 432
 433 MODULE_DESCRIPTION("Infrared receiver driver for SIR type serial ports");
 434 MODULE_AUTHOR("Milan Pikula");
 435 MODULE_LICENSE("GPL");
 436
 437 module_param(io, int, 0444);
 438 MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)");
 439
 440 module_param(irq, int, 0444);
 441 MODULE_PARM_DESC(irq, "Interrupt (4 or 3)");
 442
 443 module_param(threshold, int, 0444);
 444 MODULE_PARM_DESC(threshold, "space detection threshold (3)");