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/kthread.h>
  16 #include <linux/mutex.h>
  17 #include <linux/sched.h>
  18 #include <linux/freezer.h>
  19 #include "ir-core-priv.h"
  20
  21 /* Define the max number of pulse/space transitions to buffer */
  22 #define MAX_IR_EVENT_SIZE      512
  23
  24 /* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
  25 static LIST_HEAD(ir_raw_client_list);
  26
  27 /* Used to handle IR raw handler extensions */
  28 static DEFINE_MUTEX(ir_raw_handler_lock);
  29 static LIST_HEAD(ir_raw_handler_list);
  30 static u64 available_protocols;
  31
  32 #ifdef MODULE
  33 /* Used to load the decoders */
  34 static struct work_struct wq_load;
  35 #endif
  36
  37 static int ir_raw_event_thread(void *data)
  38 {
  39         struct ir_raw_event ev;
  40         struct ir_raw_handler *handler;
  41         struct ir_raw_event_ctrl *raw = (struct ir_raw_event_ctrl *)data;
  42
  43         while (!kthread_should_stop()) {
  44                 try_to_freeze();
  45
  46                 mutex_lock(&ir_raw_handler_lock);
  47
  48                 while (kfifo_out(&raw->kfifo, &ev, sizeof(ev)) == sizeof(ev)) {
  49                         list_for_each_entry(handler, &ir_raw_handler_list, list)
  50                                 handler->decode(raw->input_dev, ev);
  51                         raw->prev_ev = ev;
  52                 }
  53
  54                 mutex_unlock(&ir_raw_handler_lock);
  55
  56                 set_current_state(TASK_INTERRUPTIBLE);
  57                 schedule();
  58         }
  59
  60         return 0;
  61 }
  62
  63 /**
  64  * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
  65  * @input_dev:  the struct input_dev device descriptor
  66  * @ev:         the struct ir_raw_event descriptor of the pulse/space
  67  *
  68  * This routine (which may be called from an interrupt context) stores a
  69  * pulse/space duration for the raw ir decoding state machines. Pulses are
  70  * signalled as positive values and spaces as negative values. A zero value
  71  * will reset the decoding state machines.
  72  */
  73 int ir_raw_event_store(struct input_dev *input_dev, struct ir_raw_event *ev)
  74 {
  75         struct ir_input_dev *ir = input_get_drvdata(input_dev);
  76
  77         if (!ir->raw)
  78                 return -EINVAL;
  79
  80         IR_dprintk(2, "sample: (05%dus %s)\n",
  81                 TO_US(ev->duration), TO_STR(ev->pulse));
  82
  83         if (kfifo_in(&ir->raw->kfifo, ev, sizeof(*ev)) != sizeof(*ev))
  84                 return -ENOMEM;
  85
  86         return 0;
  87 }
  88 EXPORT_SYMBOL_GPL(ir_raw_event_store);
  89
  90 /**
  91  * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
  92  * @input_dev:  the struct input_dev device descriptor
  93  * @type:       the type of the event that has occurred
  94  *
  95  * This routine (which may be called from an interrupt context) is used to
  96  * store the beginning of an ir pulse or space (or the start/end of ir
  97  * reception) for the raw ir decoding state machines. This is used by
  98  * hardware which does not provide durations directly but only interrupts
  99  * (or similar events) on state change.
 100  */
 101 int ir_raw_event_store_edge(struct input_dev *input_dev, enum raw_event_type type)
 102 {
 103         struct ir_input_dev     *ir = input_get_drvdata(input_dev);
 104         ktime_t                 now;
 105         s64                     delta; /* ns */
 106         struct ir_raw_event     ev;
 107         int                     rc = 0;
 108
 109         if (!ir->raw)
 110                 return -EINVAL;
 111
 112         now = ktime_get();
 113         delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
 114
 115         /* Check for a long duration since last event or if we're
 116          * being called for the first time, note that delta can't
 117          * possibly be negative.
 118          */
 119         ev.duration = 0;
 120         if (delta > IR_MAX_DURATION || !ir->raw->last_type)
 121                 type |= IR_START_EVENT;
 122         else
 123                 ev.duration = delta;
 124
 125         if (type & IR_START_EVENT)
 126                 ir_raw_event_reset(input_dev);
 127         else if (ir->raw->last_type & IR_SPACE) {
 128                 ev.pulse = false;
 129                 rc = ir_raw_event_store(input_dev, &ev);
 130         } else if (ir->raw->last_type & IR_PULSE) {
 131                 ev.pulse = true;
 132                 rc = ir_raw_event_store(input_dev, &ev);
 133         } else
 134                 return 0;
 135
 136         ir->raw->last_event = now;
 137         ir->raw->last_type = type;
 138         return rc;
 139 }
 140 EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
 141
 142 /**
 143  * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
 144  * @input_dev:  the struct input_dev device descriptor
 145  * @type:       the type of the event that has occurred
 146  *
 147  * This routine (which may be called from an interrupt context) works
 148  * in similiar manner to ir_raw_event_store_edge.
 149  * This routine is intended for devices with limited internal buffer
 150  * It automerges samples of same type, and handles timeouts
 151  */
 152 int ir_raw_event_store_with_filter(struct input_dev *input_dev,
 153                                                 struct ir_raw_event *ev)
 154 {
 155         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 156         struct ir_raw_event_ctrl *raw = ir->raw;
 157
 158         if (!raw || !ir->props)
 159                 return -EINVAL;
 160
 161         /* Ignore spaces in idle mode */
 162         if (ir->idle && !ev->pulse)
 163                 return 0;
 164         else if (ir->idle)
 165                 ir_raw_event_set_idle(input_dev, 0);
 166
 167         if (!raw->this_ev.duration) {
 168                 raw->this_ev = *ev;
 169         } else if (ev->pulse == raw->this_ev.pulse) {
 170                 raw->this_ev.duration += ev->duration;
 171         } else {
 172                 ir_raw_event_store(input_dev, &raw->this_ev);
 173                 raw->this_ev = *ev;
 174         }
 175
 176         /* Enter idle mode if nessesary */
 177         if (!ev->pulse && ir->props->timeout &&
 178                 raw->this_ev.duration >= ir->props->timeout)
 179                 ir_raw_event_set_idle(input_dev, 1);
 180         return 0;
 181 }
 182 EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);
 183
 184 void ir_raw_event_set_idle(struct input_dev *input_dev, int idle)
 185 {
 186         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 187         struct ir_raw_event_ctrl *raw = ir->raw;
 188         ktime_t now;
 189         u64 delta;
 190
 191         if (!ir->props)
 192                 return;
 193
 194         if (!ir->raw)
 195                 goto out;
 196
 197         if (idle) {
 198                 IR_dprintk(2, "enter idle mode\n");
 199                 raw->last_event = ktime_get();
 200         } else {
 201                 IR_dprintk(2, "exit idle mode\n");
 202
 203                 now = ktime_get();
 204                 delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
 205
 206                 WARN_ON(raw->this_ev.pulse);
 207
 208                 raw->this_ev.duration =
 209                         min(raw->this_ev.duration + delta,
 210                                                 (u64)IR_MAX_DURATION);
 211
 212                 ir_raw_event_store(input_dev, &raw->this_ev);
 213
 214                 if (raw->this_ev.duration == IR_MAX_DURATION)
 215                         ir_raw_event_reset(input_dev);
 216
 217                 raw->this_ev.duration = 0;
 218         }
 219 out:
 220         if (ir->props->s_idle)
 221                 ir->props->s_idle(ir->props->priv, idle);
 222         ir->idle = idle;
 223 }
 224 EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);
 225
 226 /**
 227  * ir_raw_event_handle() - schedules the decoding of stored ir data
 228  * @input_dev:  the struct input_dev device descriptor
 229  *
 230  * This routine will signal the workqueue to start decoding stored ir data.
 231  */
 232 void ir_raw_event_handle(struct input_dev *input_dev)
 233 {
 234         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 235
 236         if (!ir->raw)
 237                 return;
 238
 239         wake_up_process(ir->raw->thread);
 240 }
 241 EXPORT_SYMBOL_GPL(ir_raw_event_handle);
 242
 243 /* used internally by the sysfs interface */
 244 u64
 245 ir_raw_get_allowed_protocols()
 246 {
 247         u64 protocols;
 248         mutex_lock(&ir_raw_handler_lock);
 249         protocols = available_protocols;
 250         mutex_unlock(&ir_raw_handler_lock);
 251         return protocols;
 252 }
 253
 254 /*
 255  * Used to (un)register raw event clients
 256  */
 257 int ir_raw_event_register(struct input_dev *input_dev)
 258 {
 259         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 260         int rc;
 261         struct ir_raw_handler *handler;
 262
 263         ir->raw = kzalloc(sizeof(*ir->raw), GFP_KERNEL);
 264         if (!ir->raw)
 265                 return -ENOMEM;
 266
 267         ir->raw->input_dev = input_dev;
 268
 269         ir->raw->enabled_protocols = ~0;
 270         rc = kfifo_alloc(&ir->raw->kfifo, sizeof(s64) * MAX_IR_EVENT_SIZE,
 271                          GFP_KERNEL);
 272         if (rc < 0) {
 273                 kfree(ir->raw);
 274                 ir->raw = NULL;
 275                 return rc;
 276         }
 277
 278         ir->raw->thread = kthread_run(ir_raw_event_thread, ir->raw,
 279                         "rc%u",  (unsigned int)ir->devno);
 280
 281         if (IS_ERR(ir->raw->thread)) {
 282                 int ret = PTR_ERR(ir->raw->thread);
 283
 284                 kfree(ir->raw);
 285                 ir->raw = NULL;
 286                 return ret;
 287         }
 288
 289         mutex_lock(&ir_raw_handler_lock);
 290         list_add_tail(&ir->raw->list, &ir_raw_client_list);
 291         list_for_each_entry(handler, &ir_raw_handler_list, list)
 292                 if (handler->raw_register)
 293                         handler->raw_register(ir->raw->input_dev);
 294         mutex_unlock(&ir_raw_handler_lock);
 295
 296         return 0;
 297 }
 298
 299 void ir_raw_event_unregister(struct input_dev *input_dev)
 300 {
 301         struct ir_input_dev *ir = input_get_drvdata(input_dev);
 302         struct ir_raw_handler *handler;
 303
 304         if (!ir->raw)
 305                 return;
 306
 307         kthread_stop(ir->raw->thread);
 308
 309         mutex_lock(&ir_raw_handler_lock);
 310         list_del(&ir->raw->list);
 311         list_for_each_entry(handler, &ir_raw_handler_list, list)
 312                 if (handler->raw_unregister)
 313                         handler->raw_unregister(ir->raw->input_dev);
 314         mutex_unlock(&ir_raw_handler_lock);
 315
 316         kfifo_free(&ir->raw->kfifo);
 317         kfree(ir->raw);
 318         ir->raw = NULL;
 319 }
 320
 321 /*
 322  * Extension interface - used to register the IR decoders
 323  */
 324
 325 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
 326 {
 327         struct ir_raw_event_ctrl *raw;
 328
 329         mutex_lock(&ir_raw_handler_lock);
 330         list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
 331         if (ir_raw_handler->raw_register)
 332                 list_for_each_entry(raw, &ir_raw_client_list, list)
 333                         ir_raw_handler->raw_register(raw->input_dev);
 334         available_protocols |= ir_raw_handler->protocols;
 335         mutex_unlock(&ir_raw_handler_lock);
 336
 337         return 0;
 338 }
 339 EXPORT_SYMBOL(ir_raw_handler_register);
 340
 341 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
 342 {
 343         struct ir_raw_event_ctrl *raw;
 344
 345         mutex_lock(&ir_raw_handler_lock);
 346         list_del(&ir_raw_handler->list);
 347         if (ir_raw_handler->raw_unregister)
 348                 list_for_each_entry(raw, &ir_raw_client_list, list)
 349                         ir_raw_handler->raw_unregister(raw->input_dev);
 350         available_protocols &= ~ir_raw_handler->protocols;
 351         mutex_unlock(&ir_raw_handler_lock);
 352 }
 353 EXPORT_SYMBOL(ir_raw_handler_unregister);
 354
 355 #ifdef MODULE
 356 static void init_decoders(struct work_struct *work)
 357 {
 358         /* Load the decoder modules */
 359
 360         load_nec_decode();
 361         load_rc5_decode();
 362         load_rc6_decode();
 363         load_jvc_decode();
 364         load_sony_decode();
 365         load_lirc_codec();
 366
 367         /* If needed, we may later add some init code. In this case,
 368            it is needed to change the CONFIG_MODULE test at ir-core.h
 369          */
 370 }
 371 #endif
 372
 373 void ir_raw_init(void)
 374 {
 375 #ifdef MODULE
 376         INIT_WORK(&wq_load, init_decoders);
 377         schedule_work(&wq_load);
 378 #endif
 379 }