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 /* Hardware */
  57 static irqreturn_t sir_interrupt(int irq, void *dev_id);
  58 static void send_space(unsigned long len);
  59 static void send_pulse(unsigned long len);
  60 static int init_hardware(void);
  61 static void drop_hardware(void);
  62 /* Initialisation */
  63
  64 static inline unsigned int sinp(int offset)
  65 {
  66         return inb(io + offset);
  67 }
  68
  69 static inline void soutp(int offset, int value)
  70 {
  71         outb(value, io + offset);
  72 }
  73
  74 /* SECTION: Communication with user-space */
  75 static int sir_tx_ir(struct rc_dev *dev, unsigned int *tx_buf,
  76                      unsigned int count)
  77 {
  78         unsigned long flags;
  79         int i;
  80
  81         local_irq_save(flags);
  82         for (i = 0; i < count;) {
  83                 if (tx_buf[i])
  84                         send_pulse(tx_buf[i]);
  85                 i++;
  86                 if (i >= count)
  87                         break;
  88                 if (tx_buf[i])
  89                         send_space(tx_buf[i]);
  90                 i++;
  91         }
  92         local_irq_restore(flags);
  93
  94         return count;
  95 }
  96
  97 static void add_read_queue(int flag, unsigned long val)
  98 {
  99         DEFINE_IR_RAW_EVENT(ev);
 100
 101         pr_debug("add flag %d with val %lu\n", flag, val);
 102
 103         /*
 104          * statistically, pulses are ~TIME_CONST/2 too long. we could
 105          * maybe make this more exact, but this is good enough
 106          */
 107         if (flag) {
 108                 /* pulse */
 109                 if (val > TIME_CONST / 2)
 110                         val -= TIME_CONST / 2;
 111                 else /* should not ever happen */
 112                         val = 1;
 113                 ev.pulse = true;
 114         } else {
 115                 val += TIME_CONST / 2;
 116         }
 117         ev.duration = US_TO_NS(val);
 118
 119         ir_raw_event_store_with_filter(rcdev, &ev);
 120 }
 121
 122 /* SECTION: Hardware */
 123 static void sir_timeout(struct timer_list *unused)
 124 {
 125         /*
 126          * if last received signal was a pulse, but receiving stopped
 127          * within the 9 bit frame, we need to finish this pulse and
 128          * simulate a signal change to from pulse to space. Otherwise
 129          * upper layers will receive two sequences next time.
 130          */
 131
 132         unsigned long flags;
 133         unsigned long pulse_end;
 134
 135         /* avoid interference with interrupt */
 136         spin_lock_irqsave(&timer_lock, flags);
 137         if (last_value) {
 138                 /* clear unread bits in UART and restart */
 139                 outb(UART_FCR_CLEAR_RCVR, io + UART_FCR);
 140                 /* determine 'virtual' pulse end: */
 141                 pulse_end = min_t(unsigned long,
 142                                   ktime_us_delta(last, last_intr_time),
 143                                   IR_MAX_DURATION);
 144                 dev_dbg(&sir_ir_dev->dev, "timeout add %d for %lu usec\n",
 145                         last_value, pulse_end);
 146                 add_read_queue(last_value, pulse_end);
 147                 last_value = 0;
 148                 last = last_intr_time;
 149         }
 150         spin_unlock_irqrestore(&timer_lock, flags);
 151         ir_raw_event_handle(rcdev);
 152 }
 153
 154 static irqreturn_t sir_interrupt(int irq, void *dev_id)
 155 {
 156         unsigned char data;
 157         ktime_t curr_time;
 158         unsigned long delt;
 159         unsigned long deltintr;
 160         unsigned long flags;
 161         int counter = 0;
 162         int iir, lsr;
 163
 164         while ((iir = inb(io + UART_IIR) & UART_IIR_ID)) {
 165                 if (++counter > 256) {
 166                         dev_err(&sir_ir_dev->dev, "Trapped in interrupt");
 167                         break;
 168                 }
 169
 170                 switch (iir & UART_IIR_ID) { /* FIXME toto treba preriedit */
 171                 case UART_IIR_MSI:
 172                         (void)inb(io + UART_MSR);
 173                         break;
 174                 case UART_IIR_RLSI:
 175                 case UART_IIR_THRI:
 176                         (void)inb(io + UART_LSR);
 177                         break;
 178                 case UART_IIR_RDI:
 179                         /* avoid interference with timer */
 180                         spin_lock_irqsave(&timer_lock, flags);
 181                         do {
 182                                 del_timer(&timerlist);
 183                                 data = inb(io + UART_RX);
 184                                 curr_time = ktime_get();
 185                                 delt = min_t(unsigned long,
 186                                              ktime_us_delta(last, curr_time),
 187                                              IR_MAX_DURATION);
 188                                 deltintr = min_t(unsigned long,
 189                                                  ktime_us_delta(last_intr_time,
 190                                                                 curr_time),
 191                                                  IR_MAX_DURATION);
 192                                 dev_dbg(&sir_ir_dev->dev, "t %lu, d %d\n",
 193                                         deltintr, (int)data);
 194                                 /*
 195                                  * if nothing came in last X cycles,
 196                                  * it was gap
 197                                  */
 198                                 if (deltintr > TIME_CONST * threshold) {
 199                                         if (last_value) {
 200                                                 dev_dbg(&sir_ir_dev->dev, "GAP\n");
 201                                                 /* simulate signal change */
 202                                                 add_read_queue(last_value,
 203                                                                delt -
 204                                                                deltintr);
 205                                                 last_value = 0;
 206                                                 last = last_intr_time;
 207                                                 delt = deltintr;
 208                                         }
 209                                 }
 210                                 data = 1;
 211                                 if (data ^ last_value) {
 212                                         /*
 213                                          * deltintr > 2*TIME_CONST, remember?
 214                                          * the other case is timeout
 215                                          */
 216                                         add_read_queue(last_value,
 217                                                        delt - TIME_CONST);
 218                                         last_value = data;
 219                                         last = curr_time;
 220                                         last = ktime_sub_us(last,
 221                                                             TIME_CONST);
 222                                 }
 223                                 last_intr_time = curr_time;
 224                                 if (data) {
 225                                         /*
 226                                          * start timer for end of
 227                                          * sequence detection
 228                                          */
 229                                         timerlist.expires = jiffies +
 230                                                                 SIR_TIMEOUT;
 231                                         add_timer(&timerlist);
 232                                 }
 233
 234                                 lsr = inb(io + UART_LSR);
 235                         } while (lsr & UART_LSR_DR); /* data ready */
 236                         spin_unlock_irqrestore(&timer_lock, flags);
 237                         break;
 238                 default:
 239                         break;
 240                 }
 241         }
 242         ir_raw_event_handle(rcdev);
 243         return IRQ_RETVAL(IRQ_HANDLED);
 244 }
 245
 246 static void send_space(unsigned long len)
 247 {
 248         usleep_range(len, len + 25);
 249 }
 250
 251 static void send_pulse(unsigned long len)
 252 {
 253         long bytes_out = len / TIME_CONST;
 254
 255         if (bytes_out == 0)
 256                 bytes_out++;
 257
 258         while (bytes_out--) {
 259                 outb(PULSE, io + UART_TX);
 260                 /* FIXME treba seriozne cakanie z char/serial.c */
 261                 while (!(inb(io + UART_LSR) & UART_LSR_THRE))
 262                         ;
 263         }
 264 }
 265
 266 static int init_hardware(void)
 267 {
 268         u8 scratch, scratch2, scratch3;
 269         unsigned long flags;
 270
 271         spin_lock_irqsave(&hardware_lock, flags);
 272
 273         /*
 274          * This is a simple port existence test, borrowed from the autoconfig
 275          * function in drivers/tty/serial/8250/8250_port.c
 276          */
 277         scratch = sinp(UART_IER);
 278         soutp(UART_IER, 0);
 279 #ifdef __i386__
 280         outb(0xff, 0x080);
 281 #endif
 282         scratch2 = sinp(UART_IER) & 0x0f;
 283         soutp(UART_IER, 0x0f);
 284 #ifdef __i386__
 285         outb(0x00, 0x080);
 286 #endif
 287         scratch3 = sinp(UART_IER) & 0x0f;
 288         soutp(UART_IER, scratch);
 289         if (scratch2 != 0 || scratch3 != 0x0f) {
 290                 /* we fail, there's nothing here */
 291                 spin_unlock_irqrestore(&hardware_lock, flags);
 292                 pr_err("port existence test failed, cannot continue\n");
 293                 return -ENODEV;
 294         }
 295
 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
 314         return 0;
 315 }
 316
 317 static void drop_hardware(void)
 318 {
 319         unsigned long flags;
 320
 321         spin_lock_irqsave(&hardware_lock, flags);
 322
 323         /* turn off interrupts */
 324         outb(0, io + UART_IER);
 325
 326         spin_unlock_irqrestore(&hardware_lock, flags);
 327 }
 328
 329 /* SECTION: Initialisation */
 330 static int sir_ir_probe(struct platform_device *dev)
 331 {
 332         int retval;
 333
 334         rcdev = devm_rc_allocate_device(&sir_ir_dev->dev, RC_DRIVER_IR_RAW);
 335         if (!rcdev)
 336                 return -ENOMEM;
 337
 338         rcdev->device_name = "SIR IrDA port";
 339         rcdev->input_phys = KBUILD_MODNAME "/input0";
 340         rcdev->input_id.bustype = BUS_HOST;
 341         rcdev->input_id.vendor = 0x0001;
 342         rcdev->input_id.product = 0x0001;
 343         rcdev->input_id.version = 0x0100;
 344         rcdev->tx_ir = sir_tx_ir;
 345         rcdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
 346         rcdev->driver_name = KBUILD_MODNAME;
 347         rcdev->map_name = RC_MAP_RC6_MCE;
 348         rcdev->timeout = IR_DEFAULT_TIMEOUT;
 349         rcdev->dev.parent = &sir_ir_dev->dev;
 350
 351         timer_setup(&timerlist, sir_timeout, 0);
 352
 353         /* get I/O port access and IRQ line */
 354         if (!devm_request_region(&sir_ir_dev->dev, io, 8, KBUILD_MODNAME)) {
 355                 pr_err("i/o port 0x%.4x already in use.\n", io);
 356                 return -EBUSY;
 357         }
 358         retval = devm_request_irq(&sir_ir_dev->dev, irq, sir_interrupt, 0,
 359                                   KBUILD_MODNAME, NULL);
 360         if (retval < 0) {
 361                 pr_err("IRQ %d already in use.\n", irq);
 362                 return retval;
 363         }
 364
 365         retval = init_hardware();
 366         if (retval) {
 367                 del_timer_sync(&timerlist);
 368                 return retval;
 369         }
 370
 371         pr_info("I/O port 0x%.4x, IRQ %d.\n", io, irq);
 372
 373         retval = devm_rc_register_device(&sir_ir_dev->dev, rcdev);
 374         if (retval < 0)
 375                 return retval;
 376
 377         return 0;
 378 }
 379
 380 static int sir_ir_remove(struct platform_device *dev)
 381 {
 382         drop_hardware();
 383         del_timer_sync(&timerlist);
 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         platform_device_unregister(sir_ir_dev);
 425         platform_driver_unregister(&sir_ir_driver);
 426 }
 427
 428 module_init(sir_ir_init);
 429 module_exit(sir_ir_exit);
 430
 431 MODULE_DESCRIPTION("Infrared receiver driver for SIR type serial ports");
 432 MODULE_AUTHOR("Milan Pikula");
 433 MODULE_LICENSE("GPL");
 434
 435 module_param_hw(io, int, ioport, 0444);
 436 MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)");
 437
 438 module_param_hw(irq, int, irq, 0444);
 439 MODULE_PARM_DESC(irq, "Interrupt (4 or 3)");
 440
 441 module_param(threshold, int, 0444);
 442 MODULE_PARM_DESC(threshold, "space detection threshold (3)");