drivers/media/IR/ir-raw-event.c

   1 /* ir-raw-event.c - handle IR Pulse/Space event
   2  *
   3  * Copyright (C) 2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation version 2 of the License.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  */
  14
  15 #include <linux/workqueue.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/sched.h>
  18 #include "ir-core-priv.h"
  19
  20 /* Define the max number of pulse/space transitions to buffer */
  21 #define MAX_IR_EVENT_SIZE      512
  22
  23 /* Used to handle IR raw handler extensions */
  24 static LIST_HEAD(ir_raw_handler_list);
  25 static DEFINE_SPINLOCK(ir_raw_handler_lock);
  26
  27 /**
  28  * RUN_DECODER()        - runs an operation on all IR decoders
  29  * @ops:        IR raw handler operation to be called
  30  * @arg:        arguments to be passed to the callback
  31  *
  32  * Calls ir_raw_handler::ops for all registered IR handlers. It prevents
  33  * new decode addition/removal while running, by locking ir_raw_handler_lock
  34  * mutex. If an error occurs, we keep going, as in the decode case, each
  35  * decoder must have a crack at decoding the data. We return a sum of the
  36  * return codes, which will be either 0 or negative for current callers.
  37  */
  38 #define RUN_DECODER(ops, ...) ({                                            \
  39         struct ir_raw_handler           *_ir_raw_handler;                   \
  40         int _sumrc = 0, _rc;                                                \
  41         spin_lock(&ir_raw_handler_lock);                                    \
  42         list_for_each_entry(_ir_raw_handler, &ir_raw_handler_list, list) {  \
  43                 if (_ir_raw_handler->ops) {                                 \
  44                         _rc = _ir_raw_handler->ops(__VA_ARGS__);            \
  45                         _sumrc += _rc;                                      \
  46                 }                                                           \
  47         }                                                                   \
  48         spin_unlock(&ir_raw_handler_lock);                                  \
  49         _sumrc;                                                             \
  50 })
  51
  52 #ifdef MODULE
  53 /* Used to load the decoders */
  54 static struct work_struct wq_load;
  55 #endif
  56
  57 static void ir_raw_event_work(struct work_struct *work)
  58 {
  59         struct ir_raw_event ev;
  60         struct ir_raw_event_ctrl *raw =
  61                 container_of(work, struct ir_raw_event_ctrl, rx_work);
  62
  63         while (kfifo_out(&raw->kfifo, &ev, sizeof(ev)) == sizeof(ev))
  64                 RUN_DECODER(decode, raw->input_dev, ev);
  65 }
  66
  67 int ir_raw_event_register(struct input_dev *input_dev)
  68 {
  69         struct ir_input_dev *ir = input_get_drvdata(input_dev);
  70         int rc;
  71
  72         ir->raw = kzalloc(sizeof(*ir->raw), GFP_KERNEL);
  73         if (!ir->raw)
  74                 return -ENOMEM;
  75
  76         ir->raw->input_dev = input_dev;
  77         INIT_WORK(&ir->raw->rx_work, ir_raw_event_work);
  78
  79         rc = kfifo_alloc(&ir->raw->kfifo, sizeof(s64) * MAX_IR_EVENT_SIZE,
  80                          GFP_KERNEL);
  81         if (rc < 0) {
  82                 kfree(ir->raw);
  83                 ir->raw = NULL;
  84                 return rc;
  85         }
  86
  87         rc = RUN_DECODER(raw_register, input_dev);
  88         if (rc < 0) {
  89                 kfifo_free(&ir->raw->kfifo);
  90                 kfree(ir->raw);
  91                 ir->raw = NULL;
  92                 return rc;
  93         }
  94
  95         return rc;
  96 }
  97
  98 void ir_raw_event_unregister(struct input_dev *input_dev)
  99 {
 100         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 101
 102         if (!ir->raw)
 103                 return;
 104
 105         cancel_work_sync(&ir->raw->rx_work);
 106         RUN_DECODER(raw_unregister, input_dev);
 107
 108         kfifo_free(&ir->raw->kfifo);
 109         kfree(ir->raw);
 110         ir->raw = NULL;
 111 }
 112
 113 /**
 114  * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
 115  * @input_dev:  the struct input_dev device descriptor
 116  * @ev:         the struct ir_raw_event descriptor of the pulse/space
 117  *
 118  * This routine (which may be called from an interrupt context) stores a
 119  * pulse/space duration for the raw ir decoding state machines. Pulses are
 120  * signalled as positive values and spaces as negative values. A zero value
 121  * will reset the decoding state machines.
 122  */
 123 int ir_raw_event_store(struct input_dev *input_dev, struct ir_raw_event *ev)
 124 {
 125         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 126
 127         if (!ir->raw)
 128                 return -EINVAL;
 129
 130         if (kfifo_in(&ir->raw->kfifo, ev, sizeof(*ev)) != sizeof(*ev))
 131                 return -ENOMEM;
 132
 133         return 0;
 134 }
 135 EXPORT_SYMBOL_GPL(ir_raw_event_store);
 136
 137 /**
 138  * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
 139  * @input_dev:  the struct input_dev device descriptor
 140  * @type:       the type of the event that has occurred
 141  *
 142  * This routine (which may be called from an interrupt context) is used to
 143  * store the beginning of an ir pulse or space (or the start/end of ir
 144  * reception) for the raw ir decoding state machines. This is used by
 145  * hardware which does not provide durations directly but only interrupts
 146  * (or similar events) on state change.
 147  */
 148 int ir_raw_event_store_edge(struct input_dev *input_dev, enum raw_event_type type)
 149 {
 150         struct ir_input_dev     *ir = input_get_drvdata(input_dev);
 151         ktime_t                 now;
 152         s64                     delta; /* ns */
 153         struct ir_raw_event     ev;
 154         int                     rc = 0;
 155
 156         if (!ir->raw)
 157                 return -EINVAL;
 158
 159         now = ktime_get();
 160         delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
 161
 162         /* Check for a long duration since last event or if we're
 163          * being called for the first time, note that delta can't
 164          * possibly be negative.
 165          */
 166         ev.duration = 0;
 167         if (delta > IR_MAX_DURATION || !ir->raw->last_type)
 168                 type |= IR_START_EVENT;
 169         else
 170                 ev.duration = delta;
 171
 172         if (type & IR_START_EVENT)
 173                 ir_raw_event_reset(input_dev);
 174         else if (ir->raw->last_type & IR_SPACE) {
 175                 ev.pulse = false;
 176                 rc = ir_raw_event_store(input_dev, &ev);
 177         } else if (ir->raw->last_type & IR_PULSE) {
 178                 ev.pulse = true;
 179                 rc = ir_raw_event_store(input_dev, &ev);
 180         } else
 181                 return 0;
 182
 183         ir->raw->last_event = now;
 184         ir->raw->last_type = type;
 185         return rc;
 186 }
 187 EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
 188
 189 /**
 190  * ir_raw_event_handle() - schedules the decoding of stored ir data
 191  * @input_dev:  the struct input_dev device descriptor
 192  *
 193  * This routine will signal the workqueue to start decoding stored ir data.
 194  */
 195 void ir_raw_event_handle(struct input_dev *input_dev)
 196 {
 197         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 198
 199         if (!ir->raw)
 200                 return;
 201
 202         schedule_work(&ir->raw->rx_work);
 203 }
 204 EXPORT_SYMBOL_GPL(ir_raw_event_handle);
 205
 206 /*
 207  * Extension interface - used to register the IR decoders
 208  */
 209
 210 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
 211 {
 212         spin_lock(&ir_raw_handler_lock);
 213         list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
 214         spin_unlock(&ir_raw_handler_lock);
 215         return 0;
 216 }
 217 EXPORT_SYMBOL(ir_raw_handler_register);
 218
 219 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
 220 {
 221         spin_lock(&ir_raw_handler_lock);
 222         list_del(&ir_raw_handler->list);
 223         spin_unlock(&ir_raw_handler_lock);
 224 }
 225 EXPORT_SYMBOL(ir_raw_handler_unregister);
 226
 227 #ifdef MODULE
 228 static void init_decoders(struct work_struct *work)
 229 {
 230         /* Load the decoder modules */
 231
 232         load_nec_decode();
 233         load_rc5_decode();
 234         load_rc6_decode();
 235         load_jvc_decode();
 236         load_sony_decode();
 237
 238         /* If needed, we may later add some init code. In this case,
 239            it is needed to change the CONFIG_MODULE test at ir-core.h
 240          */
 241 }
 242 #endif
 243
 244 void ir_raw_init(void)
 245 {
 246 #ifdef MODULE
 247         INIT_WORK(&wq_load, init_decoders);
 248         schedule_work(&wq_load);
 249 #endif
 250 }