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 iir, lsr;
 187
 188         while ((iir = inb(io + UART_IIR) & UART_IIR_ID)) {
 189                 switch (iir & UART_IIR_ID) { /* FIXME toto treba preriedit */
 190                 case UART_IIR_MSI:
 191                         (void)inb(io + UART_MSR);
 192                         break;
 193                 case UART_IIR_RLSI:
 194                 case UART_IIR_THRI:
 195                         (void)inb(io + UART_LSR);
 196                         break;
 197                 case UART_IIR_RDI:
 198                         /* avoid interference with timer */
 199                         spin_lock_irqsave(&timer_lock, flags);
 200                         do {
 201                                 del_timer(&timerlist);
 202                                 data = inb(io + UART_RX);
 203                                 curr_time = ktime_get();
 204                                 delt = min_t(unsigned long,
 205                                              ktime_us_delta(last, curr_time),
 206                                              IR_MAX_DURATION);
 207                                 deltintr = min_t(unsigned long,
 208                                                  ktime_us_delta(last_intr_time,
 209                                                                 curr_time),
 210                                                  IR_MAX_DURATION);
 211                                 dev_dbg(&sir_ir_dev->dev, "t %lu, d %d\n",
 212                                         deltintr, (int)data);
 213                                 /*
 214                                  * if nothing came in last X cycles,
 215                                  * it was gap
 216                                  */
 217                                 if (deltintr > TIME_CONST * threshold) {
 218                                         if (last_value) {
 219                                                 dev_dbg(&sir_ir_dev->dev, "GAP\n");
 220                                                 /* simulate signal change */
 221                                                 add_read_queue(last_value,
 222                                                                delt -
 223                                                                deltintr);
 224                                                 last_value = 0;
 225                                                 last = last_intr_time;
 226                                                 delt = deltintr;
 227                                         }
 228                                 }
 229                                 data = 1;
 230                                 if (data ^ last_value) {
 231                                         /*
 232                                          * deltintr > 2*TIME_CONST, remember?
 233                                          * the other case is timeout
 234                                          */
 235                                         add_read_queue(last_value,
 236                                                        delt - TIME_CONST);
 237                                         last_value = data;
 238                                         last = curr_time;
 239                                         last = ktime_sub_us(last,
 240                                                             TIME_CONST);
 241                                 }
 242                                 last_intr_time = curr_time;
 243                                 if (data) {
 244                                         /*
 245                                          * start timer for end of
 246                                          * sequence detection
 247                                          */
 248                                         timerlist.expires = jiffies +
 249                                                                 SIR_TIMEOUT;
 250                                         add_timer(&timerlist);
 251                                 }
 252
 253                                 lsr = inb(io + UART_LSR);
 254                         } while (lsr & UART_LSR_DR); /* data ready */
 255                         spin_unlock_irqrestore(&timer_lock, flags);
 256                         break;
 257                 default:
 258                         break;
 259                 }
 260         }
 261         ir_raw_event_handle(rcdev);
 262         return IRQ_RETVAL(IRQ_HANDLED);
 263 }
 264
 265 static void send_space(unsigned long len)
 266 {
 267         usleep_range(len, len + 25);
 268 }
 269
 270 static void send_pulse(unsigned long len)
 271 {
 272         long bytes_out = len / TIME_CONST;
 273
 274         if (bytes_out == 0)
 275                 bytes_out++;
 276
 277         while (bytes_out--) {
 278                 outb(PULSE, io + UART_TX);
 279                 /* FIXME treba seriozne cakanie z char/serial.c */
 280                 while (!(inb(io + UART_LSR) & UART_LSR_THRE))
 281                         ;
 282         }
 283 }
 284
 285 static int init_hardware(void)
 286 {
 287         unsigned long flags;
 288
 289         spin_lock_irqsave(&hardware_lock, flags);
 290         /* reset UART */
 291         outb(0, io + UART_MCR);
 292         outb(0, io + UART_IER);
 293         /* init UART */
 294         /* set DLAB, speed = 115200 */
 295         outb(UART_LCR_DLAB | UART_LCR_WLEN7, io + UART_LCR);
 296         outb(1, io + UART_DLL); outb(0, io + UART_DLM);
 297         /* 7N1+start = 9 bits at 115200 ~ 3 bits at 44000 */
 298         outb(UART_LCR_WLEN7, io + UART_LCR);
 299         /* FIFO operation */
 300         outb(UART_FCR_ENABLE_FIFO, io + UART_FCR);
 301         /* interrupts */
 302         /* outb(UART_IER_RLSI|UART_IER_RDI|UART_IER_THRI, io + UART_IER); */
 303         outb(UART_IER_RDI, io + UART_IER);
 304         /* turn on UART */
 305         outb(UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2, io + UART_MCR);
 306         spin_unlock_irqrestore(&hardware_lock, flags);
 307         return 0;
 308 }
 309
 310 static void drop_hardware(void)
 311 {
 312         unsigned long flags;
 313
 314         spin_lock_irqsave(&hardware_lock, flags);
 315
 316         /* turn off interrupts */
 317         outb(0, io + UART_IER);
 318
 319         spin_unlock_irqrestore(&hardware_lock, flags);
 320 }
 321
 322 /* SECTION: Initialisation */
 323
 324 static int init_port(void)
 325 {
 326         int retval;
 327
 328         setup_timer(&timerlist, sir_timeout, 0);
 329
 330         /* get I/O port access and IRQ line */
 331         if (!request_region(io, 8, KBUILD_MODNAME)) {
 332                 pr_err("i/o port 0x%.4x already in use.\n", io);
 333                 return -EBUSY;
 334         }
 335         retval = request_irq(irq, sir_interrupt, 0,
 336                              KBUILD_MODNAME, NULL);
 337         if (retval < 0) {
 338                 release_region(io, 8);
 339                 pr_err("IRQ %d already in use.\n", irq);
 340                 return retval;
 341         }
 342         pr_info("I/O port 0x%.4x, IRQ %d.\n", io, irq);
 343
 344         return 0;
 345 }
 346
 347 static void drop_port(void)
 348 {
 349         free_irq(irq, NULL);
 350         del_timer_sync(&timerlist);
 351         release_region(io, 8);
 352 }
 353
 354 static int init_sir_ir(void)
 355 {
 356         int retval;
 357
 358         retval = init_port();
 359         if (retval < 0)
 360                 return retval;
 361         init_hardware();
 362         return 0;
 363 }
 364
 365 static int sir_ir_probe(struct platform_device *dev)
 366 {
 367         int retval;
 368
 369         retval = init_chrdev();
 370         if (retval < 0)
 371                 return retval;
 372
 373         return init_sir_ir();
 374 }
 375
 376 static int sir_ir_remove(struct platform_device *dev)
 377 {
 378         return 0;
 379 }
 380
 381 static struct platform_driver sir_ir_driver = {
 382         .probe          = sir_ir_probe,
 383         .remove         = sir_ir_remove,
 384         .driver         = {
 385                 .name   = "sir_ir",
 386         },
 387 };
 388
 389 static int __init sir_ir_init(void)
 390 {
 391         int retval;
 392
 393         retval = platform_driver_register(&sir_ir_driver);
 394         if (retval)
 395                 return retval;
 396
 397         sir_ir_dev = platform_device_alloc("sir_ir", 0);
 398         if (!sir_ir_dev) {
 399                 retval = -ENOMEM;
 400                 goto pdev_alloc_fail;
 401         }
 402
 403         retval = platform_device_add(sir_ir_dev);
 404         if (retval)
 405                 goto pdev_add_fail;
 406
 407         return 0;
 408
 409 pdev_add_fail:
 410         platform_device_put(sir_ir_dev);
 411 pdev_alloc_fail:
 412         platform_driver_unregister(&sir_ir_driver);
 413         return retval;
 414 }
 415
 416 static void __exit sir_ir_exit(void)
 417 {
 418         drop_hardware();
 419         drop_port();
 420         platform_device_unregister(sir_ir_dev);
 421         platform_driver_unregister(&sir_ir_driver);
 422 }
 423
 424 module_init(sir_ir_init);
 425 module_exit(sir_ir_exit);
 426
 427 MODULE_DESCRIPTION("Infrared receiver driver for SIR type serial ports");
 428 MODULE_AUTHOR("Milan Pikula");
 429 MODULE_LICENSE("GPL");
 430
 431 module_param(io, int, 0444);
 432 MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)");
 433
 434 module_param(irq, int, 0444);
 435 MODULE_PARM_DESC(irq, "Interrupt (4 or 3)");
 436
 437 module_param(threshold, int, 0444);
 438 MODULE_PARM_DESC(threshold, "space detection threshold (3)");