drivers/media/rc/rc-core-priv.h

   1 /*
   2  * Remote Controller core raw events header
   3  *
   4  * Copyright (C) 2010 by Mauro Carvalho Chehab
   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
   8  *  the Free Software Foundation version 2 of the License.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  */
  15
  16 #ifndef _RC_CORE_PRIV
  17 #define _RC_CORE_PRIV
  18
  19 /* Define the max number of pulse/space transitions to buffer */
  20 #define MAX_IR_EVENT_SIZE       512
  21
  22 #include <linux/slab.h>
  23 #include <linux/spinlock.h>
  24 #include <media/rc-core.h>
  25
  26 struct ir_raw_handler {
  27         struct list_head list;
  28
  29         u64 protocols; /* which are handled by this handler */
  30         int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
  31
  32         /* These two should only be used by the lirc decoder */
  33         int (*raw_register)(struct rc_dev *dev);
  34         int (*raw_unregister)(struct rc_dev *dev);
  35 };
  36
  37 struct ir_raw_event_ctrl {
  38         struct list_head                list;           /* to keep track of raw clients */
  39         struct task_struct              *thread;
  40         spinlock_t                      lock;
  41         /* fifo for the pulse/space durations */
  42         DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE);
  43         ktime_t                         last_event;     /* when last event occurred */
  44         enum raw_event_type             last_type;      /* last event type */
  45         struct rc_dev                   *dev;           /* pointer to the parent rc_dev */
  46
  47         /* raw decoder state follows */
  48         struct ir_raw_event prev_ev;
  49         struct ir_raw_event this_ev;
  50         struct nec_dec {
  51                 int state;
  52                 unsigned count;
  53                 u32 bits;
  54                 bool is_nec_x;
  55                 bool necx_repeat;
  56         } nec;
  57         struct rc5_dec {
  58                 int state;
  59                 u32 bits;
  60                 unsigned count;
  61                 bool is_rc5x;
  62         } rc5;
  63         struct rc6_dec {
  64                 int state;
  65                 u8 header;
  66                 u32 body;
  67                 bool toggle;
  68                 unsigned count;
  69                 unsigned wanted_bits;
  70         } rc6;
  71         struct sony_dec {
  72                 int state;
  73                 u32 bits;
  74                 unsigned count;
  75         } sony;
  76         struct jvc_dec {
  77                 int state;
  78                 u16 bits;
  79                 u16 old_bits;
  80                 unsigned count;
  81                 bool first;
  82                 bool toggle;
  83         } jvc;
  84         struct sanyo_dec {
  85                 int state;
  86                 unsigned count;
  87                 u64 bits;
  88         } sanyo;
  89         struct sharp_dec {
  90                 int state;
  91                 unsigned count;
  92                 u32 bits;
  93                 unsigned int pulse_len;
  94         } sharp;
  95         struct mce_kbd_dec {
  96                 struct input_dev *idev;
  97                 struct timer_list rx_timeout;
  98                 char name[64];
  99                 char phys[64];
 100                 int state;
 101                 u8 header;
 102                 u32 body;
 103                 unsigned count;
 104                 unsigned wanted_bits;
 105         } mce_kbd;
 106         struct lirc_codec {
 107                 struct rc_dev *dev;
 108                 struct lirc_driver *drv;
 109                 int carrier_low;
 110
 111                 ktime_t gap_start;
 112                 u64 gap_duration;
 113                 bool gap;
 114                 bool send_timeout_reports;
 115
 116         } lirc;
 117         struct xmp_dec {
 118                 int state;
 119                 unsigned count;
 120                 u32 durations[16];
 121         } xmp;
 122 };
 123
 124 /* macros for IR decoders */
 125 static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
 126 {
 127         return d1 > (d2 - margin);
 128 }
 129
 130 static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
 131 {
 132         return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
 133 }
 134
 135 static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
 136 {
 137         return x->pulse != y->pulse;
 138 }
 139
 140 static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
 141 {
 142         if (duration > ev->duration)
 143                 ev->duration = 0;
 144         else
 145                 ev->duration -= duration;
 146 }
 147
 148 /* Returns true if event is normal pulse/space event */
 149 static inline bool is_timing_event(struct ir_raw_event ev)
 150 {
 151         return !ev.carrier_report && !ev.reset;
 152 }
 153
 154 #define TO_US(duration)                 DIV_ROUND_CLOSEST((duration), 1000)
 155 #define TO_STR(is_pulse)                ((is_pulse) ? "pulse" : "space")
 156
 157 /*
 158  * Routines from rc-raw.c to be used internally and by decoders
 159  */
 160 u64 ir_raw_get_allowed_protocols(void);
 161 int ir_raw_event_register(struct rc_dev *dev);
 162 void ir_raw_event_unregister(struct rc_dev *dev);
 163 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
 164 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
 165 void ir_raw_init(void);
 166
 167 /*
 168  * Decoder initialization code
 169  *
 170  * Those load logic are called during ir-core init, and automatically
 171  * loads the compiled decoders for their usage with IR raw events
 172  */
 173
 174 #endif /* _RC_CORE_PRIV */