drivers/media/rc/img-ir/img-ir-raw.c

   1 /*
   2  * ImgTec IR Raw Decoder found in PowerDown Controller.
   3  *
   4  * Copyright 2010-2014 Imagination Technologies Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2 of the License, or (at your
   9  * option) any later version.
  10  *
  11  * This ties into the input subsystem using the RC-core in raw mode. Raw IR
  12  * signal edges are reported and decoded by generic software decoders.
  13  */
  14
  15 #include <linux/spinlock.h>
  16 #include <media/rc-core.h>
  17 #include "img-ir.h"
  18
  19 #define ECHO_TIMEOUT_MS 150     /* ms between echos */
  20
  21 /* must be called with priv->lock held */
  22 static void img_ir_refresh_raw(struct img_ir_priv *priv, u32 irq_status)
  23 {
  24         struct img_ir_priv_raw *raw = &priv->raw;
  25         struct rc_dev *rc_dev = priv->raw.rdev;
  26         int multiple;
  27         u32 ir_status;
  28
  29         /* find whether both rise and fall was detected */
  30         multiple = ((irq_status & IMG_IR_IRQ_EDGE) == IMG_IR_IRQ_EDGE);
  31         /*
  32          * If so, we need to see if the level has actually changed.
  33          * If it's just noise that we didn't have time to process,
  34          * there's no point reporting it.
  35          */
  36         ir_status = img_ir_read(priv, IMG_IR_STATUS) & IMG_IR_IRRXD;
  37         if (multiple && ir_status == raw->last_status)
  38                 return;
  39         raw->last_status = ir_status;
  40
  41         /* report the edge to the IR raw decoders */
  42         if (ir_status) /* low */
  43                 ir_raw_event_store_edge(rc_dev, false);
  44         else /* high */
  45                 ir_raw_event_store_edge(rc_dev, true);
  46         ir_raw_event_handle(rc_dev);
  47 }
  48
  49 /* called with priv->lock held */
  50 void img_ir_isr_raw(struct img_ir_priv *priv, u32 irq_status)
  51 {
  52         struct img_ir_priv_raw *raw = &priv->raw;
  53
  54         /* check not removing */
  55         if (!raw->rdev)
  56                 return;
  57
  58         img_ir_refresh_raw(priv, irq_status);
  59
  60         /* start / push back the echo timer */
  61         mod_timer(&raw->timer, jiffies + msecs_to_jiffies(ECHO_TIMEOUT_MS));
  62 }
  63
  64 /*
  65  * Echo timer callback function.
  66  * The raw decoders expect to get a final sample even if there are no edges, in
  67  * order to be assured of the final space. If there are no edges for a certain
  68  * time we use this timer to emit a final sample to satisfy them.
  69  */
  70 static void img_ir_echo_timer(struct timer_list *t)
  71 {
  72         struct img_ir_priv *priv = from_timer(priv, t, raw.timer);
  73
  74         spin_lock_irq(&priv->lock);
  75
  76         /* check not removing */
  77         if (priv->raw.rdev)
  78                 /*
  79                  * It's safe to pass irq_status=0 since it's only used to check
  80                  * for double edges.
  81                  */
  82                 img_ir_refresh_raw(priv, 0);
  83
  84         spin_unlock_irq(&priv->lock);
  85 }
  86
  87 void img_ir_setup_raw(struct img_ir_priv *priv)
  88 {
  89         u32 irq_en;
  90
  91         if (!priv->raw.rdev)
  92                 return;
  93
  94         /* clear and enable edge interrupts */
  95         spin_lock_irq(&priv->lock);
  96         irq_en = img_ir_read(priv, IMG_IR_IRQ_ENABLE);
  97         irq_en |= IMG_IR_IRQ_EDGE;
  98         img_ir_write(priv, IMG_IR_IRQ_CLEAR, IMG_IR_IRQ_EDGE);
  99         img_ir_write(priv, IMG_IR_IRQ_ENABLE, irq_en);
 100         spin_unlock_irq(&priv->lock);
 101 }
 102
 103 int img_ir_probe_raw(struct img_ir_priv *priv)
 104 {
 105         struct img_ir_priv_raw *raw = &priv->raw;
 106         struct rc_dev *rdev;
 107         int error;
 108
 109         /* Set up the echo timer */
 110         timer_setup(&raw->timer, img_ir_echo_timer, 0);
 111
 112         /* Allocate raw decoder */
 113         raw->rdev = rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
 114         if (!rdev) {
 115                 dev_err(priv->dev, "cannot allocate raw input device\n");
 116                 return -ENOMEM;
 117         }
 118         rdev->priv = priv;
 119         rdev->map_name = RC_MAP_EMPTY;
 120         rdev->device_name = "IMG Infrared Decoder Raw";
 121
 122         /* Register raw decoder */
 123         error = rc_register_device(rdev);
 124         if (error) {
 125                 dev_err(priv->dev, "failed to register raw IR input device\n");
 126                 rc_free_device(rdev);
 127                 raw->rdev = NULL;
 128                 return error;
 129         }
 130
 131         return 0;
 132 }
 133
 134 void img_ir_remove_raw(struct img_ir_priv *priv)
 135 {
 136         struct img_ir_priv_raw *raw = &priv->raw;
 137         struct rc_dev *rdev = raw->rdev;
 138         u32 irq_en;
 139
 140         if (!rdev)
 141                 return;
 142
 143         /* switch off and disable raw (edge) interrupts */
 144         spin_lock_irq(&priv->lock);
 145         raw->rdev = NULL;
 146         irq_en = img_ir_read(priv, IMG_IR_IRQ_ENABLE);
 147         irq_en &= ~IMG_IR_IRQ_EDGE;
 148         img_ir_write(priv, IMG_IR_IRQ_ENABLE, irq_en);
 149         img_ir_write(priv, IMG_IR_IRQ_CLEAR, IMG_IR_IRQ_EDGE);
 150         spin_unlock_irq(&priv->lock);
 151
 152         rc_unregister_device(rdev);
 153
 154         del_timer_sync(&raw->timer);
 155 }