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 #include <linux/slab.h>
  20 #include <linux/spinlock.h>
  21 #include <media/rc-core.h>
  22
  23 struct ir_raw_handler {
  24         struct list_head list;
  25
  26         u64 protocols; /* which are handled by this handler */
  27         int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
  28         int (*encode)(u64 protocols, const struct rc_scancode_filter *scancode,
  29                       struct ir_raw_event *events, unsigned int max);
  30
  31         /* These two should only be used by the lirc decoder */
  32         int (*raw_register)(struct rc_dev *dev);
  33         int (*raw_unregister)(struct rc_dev *dev);
  34 };
  35
  36 struct ir_raw_event_ctrl {
  37         struct list_head                list;           /* to keep track of raw clients */
  38         struct task_struct              *thread;
  39         spinlock_t                      lock;
  40         struct kfifo_rec_ptr_1          kfifo;          /* fifo for the pulse/space durations */
  41         ktime_t                         last_event;     /* when last event occurred */
  42         enum raw_event_type             last_type;      /* last event type */
  43         struct rc_dev                   *dev;           /* pointer to the parent rc_dev */
  44
  45         /* raw decoder state follows */
  46         struct ir_raw_event prev_ev;
  47         struct ir_raw_event this_ev;
  48         struct nec_dec {
  49                 int state;
  50                 unsigned count;
  51                 u32 bits;
  52                 bool is_nec_x;
  53                 bool necx_repeat;
  54         } nec;
  55         struct rc5_dec {
  56                 int state;
  57                 u32 bits;
  58                 unsigned count;
  59                 bool is_rc5x;
  60         } rc5;
  61         struct rc6_dec {
  62                 int state;
  63                 u8 header;
  64                 u32 body;
  65                 bool toggle;
  66                 unsigned count;
  67                 unsigned wanted_bits;
  68         } rc6;
  69         struct sony_dec {
  70                 int state;
  71                 u32 bits;
  72                 unsigned count;
  73         } sony;
  74         struct jvc_dec {
  75                 int state;
  76                 u16 bits;
  77                 u16 old_bits;
  78                 unsigned count;
  79                 bool first;
  80                 bool toggle;
  81         } jvc;
  82         struct sanyo_dec {
  83                 int state;
  84                 unsigned count;
  85                 u64 bits;
  86         } sanyo;
  87         struct sharp_dec {
  88                 int state;
  89                 unsigned count;
  90                 u32 bits;
  91                 unsigned int pulse_len;
  92         } sharp;
  93         struct mce_kbd_dec {
  94                 struct input_dev *idev;
  95                 struct timer_list rx_timeout;
  96                 char name[64];
  97                 char phys[64];
  98                 int state;
  99                 u8 header;
 100                 u32 body;
 101                 unsigned count;
 102                 unsigned wanted_bits;
 103         } mce_kbd;
 104         struct lirc_codec {
 105                 struct rc_dev *dev;
 106                 struct lirc_driver *drv;
 107                 int carrier_low;
 108
 109                 ktime_t gap_start;
 110                 u64 gap_duration;
 111                 bool gap;
 112                 bool send_timeout_reports;
 113
 114         } lirc;
 115         struct xmp_dec {
 116                 int state;
 117                 unsigned count;
 118                 u32 durations[16];
 119         } xmp;
 120 };
 121
 122 /* macros for IR decoders */
 123 static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
 124 {
 125         return d1 > (d2 - margin);
 126 }
 127
 128 static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
 129 {
 130         return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
 131 }
 132
 133 static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
 134 {
 135         return x->pulse != y->pulse;
 136 }
 137
 138 static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
 139 {
 140         if (duration > ev->duration)
 141                 ev->duration = 0;
 142         else
 143                 ev->duration -= duration;
 144 }
 145
 146 /* Returns true if event is normal pulse/space event */
 147 static inline bool is_timing_event(struct ir_raw_event ev)
 148 {
 149         return !ev.carrier_report && !ev.reset;
 150 }
 151
 152 #define TO_US(duration)                 DIV_ROUND_CLOSEST((duration), 1000)
 153 #define TO_STR(is_pulse)                ((is_pulse) ? "pulse" : "space")
 154
 155 /* functions for IR encoders */
 156
 157 static inline void init_ir_raw_event_duration(struct ir_raw_event *ev,
 158                                               unsigned int pulse,
 159                                               u32 duration)
 160 {
 161         init_ir_raw_event(ev);
 162         ev->duration = duration;
 163         ev->pulse = pulse;
 164 }
 165
 166 /**
 167  * struct ir_raw_timings_manchester - Manchester coding timings
 168  * @leader:             duration of leader pulse (if any) 0 if continuing
 169  *                      existing signal (see @pulse_space_start)
 170  * @pulse_space_start:  1 for starting with pulse (0 for starting with space)
 171  * @clock:              duration of each pulse/space in ns
 172  * @invert:             if set clock logic is inverted
 173  *                      (0 = space + pulse, 1 = pulse + space)
 174  * @trailer_space:      duration of trailer space in ns
 175  */
 176 struct ir_raw_timings_manchester {
 177         unsigned int leader;
 178         unsigned int pulse_space_start:1;
 179         unsigned int clock;
 180         unsigned int invert:1;
 181         unsigned int trailer_space;
 182 };
 183
 184 int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
 185                           const struct ir_raw_timings_manchester *timings,
 186                           unsigned int n, unsigned int data);
 187
 188 /*
 189  * Routines from rc-raw.c to be used internally and by decoders
 190  */
 191 u64 ir_raw_get_allowed_protocols(void);
 192 u64 ir_raw_get_encode_protocols(void);
 193 int ir_raw_event_register(struct rc_dev *dev);
 194 void ir_raw_event_unregister(struct rc_dev *dev);
 195 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
 196 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
 197 void ir_raw_init(void);
 198
 199 /*
 200  * Decoder initialization code
 201  *
 202  * Those load logic are called during ir-core init, and automatically
 203  * loads the compiled decoders for their usage with IR raw events
 204  */
 205
 206 /* from ir-nec-decoder.c */
 207 #ifdef CONFIG_IR_NEC_DECODER_MODULE
 208 #define load_nec_decode()       request_module_nowait("ir-nec-decoder")
 209 #else
 210 static inline void load_nec_decode(void) { }
 211 #endif
 212
 213 /* from ir-rc5-decoder.c */
 214 #ifdef CONFIG_IR_RC5_DECODER_MODULE
 215 #define load_rc5_decode()       request_module_nowait("ir-rc5-decoder")
 216 #else
 217 static inline void load_rc5_decode(void) { }
 218 #endif
 219
 220 /* from ir-rc6-decoder.c */
 221 #ifdef CONFIG_IR_RC6_DECODER_MODULE
 222 #define load_rc6_decode()       request_module_nowait("ir-rc6-decoder")
 223 #else
 224 static inline void load_rc6_decode(void) { }
 225 #endif
 226
 227 /* from ir-jvc-decoder.c */
 228 #ifdef CONFIG_IR_JVC_DECODER_MODULE
 229 #define load_jvc_decode()       request_module_nowait("ir-jvc-decoder")
 230 #else
 231 static inline void load_jvc_decode(void) { }
 232 #endif
 233
 234 /* from ir-sony-decoder.c */
 235 #ifdef CONFIG_IR_SONY_DECODER_MODULE
 236 #define load_sony_decode()      request_module_nowait("ir-sony-decoder")
 237 #else
 238 static inline void load_sony_decode(void) { }
 239 #endif
 240
 241 /* from ir-sanyo-decoder.c */
 242 #ifdef CONFIG_IR_SANYO_DECODER_MODULE
 243 #define load_sanyo_decode()     request_module_nowait("ir-sanyo-decoder")
 244 #else
 245 static inline void load_sanyo_decode(void) { }
 246 #endif
 247
 248 /* from ir-sharp-decoder.c */
 249 #ifdef CONFIG_IR_SHARP_DECODER_MODULE
 250 #define load_sharp_decode()     request_module_nowait("ir-sharp-decoder")
 251 #else
 252 static inline void load_sharp_decode(void) { }
 253 #endif
 254
 255 /* from ir-mce_kbd-decoder.c */
 256 #ifdef CONFIG_IR_MCE_KBD_DECODER_MODULE
 257 #define load_mce_kbd_decode()   request_module_nowait("ir-mce_kbd-decoder")
 258 #else
 259 static inline void load_mce_kbd_decode(void) { }
 260 #endif
 261
 262 /* from ir-lirc-codec.c */
 263 #ifdef CONFIG_IR_LIRC_CODEC_MODULE
 264 #define load_lirc_codec()       request_module_nowait("ir-lirc-codec")
 265 #else
 266 static inline void load_lirc_codec(void) { }
 267 #endif
 268
 269 /* from ir-xmp-decoder.c */
 270 #ifdef CONFIG_IR_XMP_DECODER_MODULE
 271 #define load_xmp_decode()      request_module_nowait("ir-xmp-decoder")
 272 #else
 273 static inline void load_xmp_decode(void) { }
 274 #endif
 275
 276
 277 #endif /* _RC_CORE_PRIV */