SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 <media/ir-core.h>
  16 #include <linux/workqueue.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/sched.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, it stops the ops. Otherwise, it returns a sum
  35  * of the return codes.
  36  */
  37 #define RUN_DECODER(ops, ...) ({                                            \
  38         struct ir_raw_handler           *_ir_raw_handler;                   \
  39         int _sumrc = 0, _rc;                                                \
  40         spin_lock(&ir_raw_handler_lock);                                    \
  41         list_for_each_entry(_ir_raw_handler, &ir_raw_handler_list, list) {  \
  42                 if (_ir_raw_handler->ops) {                                 \
  43                         _rc = _ir_raw_handler->ops(__VA_ARGS__);            \
  44                         if (_rc < 0)                                        \
  45                                 break;                                      \
  46                         _sumrc += _rc;                                      \
  47                 }                                                           \
  48         }                                                                   \
  49         spin_unlock(&ir_raw_handler_lock);                                  \
  50         _sumrc;                                                             \
  51 })
  52
  53
  54 /* Used to load the decoders */
  55 static struct work_struct wq_load;
  56
  57 static void ir_raw_event_work(struct work_struct *work)
  58 {
  59         s64 d;
  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, &d, sizeof(d)) == sizeof(d))
  64                 RUN_DECODER(decode, raw->input_dev, d);
  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  * @duration:   duration of the pulse or space in ns
 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, s64 duration)
 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, &duration, sizeof(duration)) != sizeof(duration))
 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         int                     rc = 0;
 154
 155         if (!ir->raw)
 156                 return -EINVAL;
 157
 158         now = ktime_get();
 159         delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
 160
 161         /* Check for a long duration since last event or if we're
 162          * being called for the first time, note that delta can't
 163          * possibly be negative.
 164          */
 165         if (delta > NSEC_PER_SEC || !ir->raw->last_type)
 166                 type |= IR_START_EVENT;
 167
 168         if (type & IR_START_EVENT)
 169                 ir_raw_event_reset(input_dev);
 170         else if (ir->raw->last_type & IR_SPACE)
 171                 rc = ir_raw_event_store(input_dev, -delta);
 172         else if (ir->raw->last_type & IR_PULSE)
 173                 rc = ir_raw_event_store(input_dev, delta);
 174         else
 175                 return 0;
 176
 177         ir->raw->last_event = now;
 178         ir->raw->last_type = type;
 179         return rc;
 180 }
 181 EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
 182
 183 /**
 184  * ir_raw_event_handle() - schedules the decoding of stored ir data
 185  * @input_dev:  the struct input_dev device descriptor
 186  *
 187  * This routine will signal the workqueue to start decoding stored ir data.
 188  */
 189 void ir_raw_event_handle(struct input_dev *input_dev)
 190 {
 191         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 192
 193         if (!ir->raw)
 194                 return;
 195
 196         schedule_work(&ir->raw->rx_work);
 197 }
 198 EXPORT_SYMBOL_GPL(ir_raw_event_handle);
 199
 200 /*
 201  * Extension interface - used to register the IR decoders
 202  */
 203
 204 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
 205 {
 206         spin_lock(&ir_raw_handler_lock);
 207         list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
 208         spin_unlock(&ir_raw_handler_lock);
 209         return 0;
 210 }
 211 EXPORT_SYMBOL(ir_raw_handler_register);
 212
 213 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
 214 {
 215         spin_lock(&ir_raw_handler_lock);
 216         list_del(&ir_raw_handler->list);
 217         spin_unlock(&ir_raw_handler_lock);
 218 }
 219 EXPORT_SYMBOL(ir_raw_handler_unregister);
 220
 221 static void init_decoders(struct work_struct *work)
 222 {
 223         /* Load the decoder modules */
 224
 225         load_nec_decode();
 226         load_rc5_decode();
 227
 228         /* If needed, we may later add some init code. In this case,
 229            it is needed to change the CONFIG_MODULE test at ir-core.h
 230          */
 231 }
 232
 233 void ir_raw_init(void)
 234 {
 235 #ifdef MODULE
 236         INIT_WORK(&wq_load, init_decoders);
 237         schedule_work(&wq_load);
 238 #endif
 239 }