1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Remote Controller core raw events header 4 * 5 * Copyright (C) 2010 by Mauro Carvalho Chehab 6 */ 7 8 #ifndef _RC_CORE_PRIV 9 #define _RC_CORE_PRIV 10 11 #define RC_DEV_MAX 256 12 /* Define the max number of pulse/space transitions to buffer */ 13 #define MAX_IR_EVENT_SIZE 512 14 15 #include <linux/slab.h> 16 #include <uapi/linux/bpf.h> 17 #include <media/rc-core.h> 18 19 /** 20 * rc_open - Opens a RC device 21 * 22 * @rdev: pointer to struct rc_dev. 23 */ 24 int rc_open(struct rc_dev *rdev); 25 26 /** 27 * rc_close - Closes a RC device 28 * 29 * @rdev: pointer to struct rc_dev. 30 */ 31 void rc_close(struct rc_dev *rdev); 32 33 struct ir_raw_handler { 34 struct list_head list; 35 36 u64 protocols; /* which are handled by this handler */ 37 int (*decode)(struct rc_dev *dev, struct ir_raw_event event); 38 int (*encode)(enum rc_proto protocol, u32 scancode, 39 struct ir_raw_event *events, unsigned int max); 40 u32 carrier; 41 u32 min_timeout; 42 43 /* These two should only be used by the mce kbd decoder */ 44 int (*raw_register)(struct rc_dev *dev); 45 int (*raw_unregister)(struct rc_dev *dev); 46 }; 47 48 struct ir_raw_event_ctrl { 49 struct list_head list; /* to keep track of raw clients */ 50 struct task_struct *thread; 51 /* fifo for the pulse/space durations */ 52 DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE); 53 ktime_t last_event; /* when last event occurred */ 54 struct rc_dev *dev; /* pointer to the parent rc_dev */ 55 /* handle delayed ir_raw_event_store_edge processing */ 56 spinlock_t edge_spinlock; 57 struct timer_list edge_handle; 58 59 /* raw decoder state follows */ 60 struct ir_raw_event prev_ev; 61 struct ir_raw_event this_ev; 62 63 #ifdef CONFIG_BPF_LIRC_MODE2 64 u32 bpf_sample; 65 struct bpf_prog_array __rcu *progs; 66 #endif 67 #if IS_ENABLED(CONFIG_IR_NEC_DECODER) 68 struct nec_dec { 69 int state; 70 unsigned count; 71 u32 bits; 72 bool is_nec_x; 73 bool necx_repeat; 74 } nec; 75 #endif 76 #if IS_ENABLED(CONFIG_IR_RC5_DECODER) 77 struct rc5_dec { 78 int state; 79 u32 bits; 80 unsigned count; 81 bool is_rc5x; 82 } rc5; 83 #endif 84 #if IS_ENABLED(CONFIG_IR_RC6_DECODER) 85 struct rc6_dec { 86 int state; 87 u8 header; 88 u32 body; 89 bool toggle; 90 unsigned count; 91 unsigned wanted_bits; 92 } rc6; 93 #endif 94 #if IS_ENABLED(CONFIG_IR_SONY_DECODER) 95 struct sony_dec { 96 int state; 97 u32 bits; 98 unsigned count; 99 } sony; 100 #endif 101 #if IS_ENABLED(CONFIG_IR_JVC_DECODER) 102 struct jvc_dec { 103 int state; 104 u16 bits; 105 u16 old_bits; 106 unsigned count; 107 bool first; 108 bool toggle; 109 } jvc; 110 #endif 111 #if IS_ENABLED(CONFIG_IR_SANYO_DECODER) 112 struct sanyo_dec { 113 int state; 114 unsigned count; 115 u64 bits; 116 } sanyo; 117 #endif 118 #if IS_ENABLED(CONFIG_IR_SHARP_DECODER) 119 struct sharp_dec { 120 int state; 121 unsigned count; 122 u32 bits; 123 unsigned int pulse_len; 124 } sharp; 125 #endif 126 #if IS_ENABLED(CONFIG_IR_MCE_KBD_DECODER) 127 struct mce_kbd_dec { 128 /* locks key up timer */ 129 spinlock_t keylock; 130 struct timer_list rx_timeout; 131 int state; 132 u8 header; 133 u32 body; 134 unsigned count; 135 unsigned wanted_bits; 136 } mce_kbd; 137 #endif 138 #if IS_ENABLED(CONFIG_IR_XMP_DECODER) 139 struct xmp_dec { 140 int state; 141 unsigned count; 142 u32 durations[16]; 143 } xmp; 144 #endif 145 #if IS_ENABLED(CONFIG_IR_IMON_DECODER) 146 struct imon_dec { 147 int state; 148 int count; 149 int last_chk; 150 unsigned int bits; 151 bool stick_keyboard; 152 } imon; 153 #endif 154 #if IS_ENABLED(CONFIG_IR_RCMM_DECODER) 155 struct rcmm_dec { 156 int state; 157 unsigned int count; 158 u32 bits; 159 } rcmm; 160 #endif 161 }; 162 163 /* Mutex for locking raw IR processing and handler change */ 164 extern struct mutex ir_raw_handler_lock; 165 166 /* macros for IR decoders */ 167 static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin) 168 { 169 return d1 > (d2 - margin); 170 } 171 172 static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin) 173 { 174 return ((d1 > (d2 - margin)) && (d1 < (d2 + margin))); 175 } 176 177 static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y) 178 { 179 return x->pulse != y->pulse; 180 } 181 182 static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration) 183 { 184 if (duration > ev->duration) 185 ev->duration = 0; 186 else 187 ev->duration -= duration; 188 } 189 190 /* Returns true if event is normal pulse/space event */ 191 static inline bool is_timing_event(struct ir_raw_event ev) 192 { 193 return !ev.carrier_report && !ev.reset; 194 } 195 196 #define TO_STR(is_pulse) ((is_pulse) ? "pulse" : "space") 197 198 /* functions for IR encoders */ 199 bool rc_validate_scancode(enum rc_proto proto, u32 scancode); 200 201 static inline void init_ir_raw_event_duration(struct ir_raw_event *ev, 202 unsigned int pulse, 203 u32 duration) 204 { 205 *ev = (struct ir_raw_event) { 206 .duration = duration, 207 .pulse = pulse 208 }; 209 } 210 211 /** 212 * struct ir_raw_timings_manchester - Manchester coding timings 213 * @leader_pulse: duration of leader pulse (if any) 0 if continuing 214 * existing signal 215 * @leader_space: duration of leader space (if any) 216 * @clock: duration of each pulse/space in ns 217 * @invert: if set clock logic is inverted 218 * (0 = space + pulse, 1 = pulse + space) 219 * @trailer_space: duration of trailer space in ns 220 */ 221 struct ir_raw_timings_manchester { 222 unsigned int leader_pulse; 223 unsigned int leader_space; 224 unsigned int clock; 225 unsigned int invert:1; 226 unsigned int trailer_space; 227 }; 228 229 int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max, 230 const struct ir_raw_timings_manchester *timings, 231 unsigned int n, u64 data); 232 233 /** 234 * ir_raw_gen_pulse_space() - generate pulse and space raw events. 235 * @ev: Pointer to pointer to next free raw event. 236 * Will be incremented for each raw event written. 237 * @max: Pointer to number of raw events available in buffer. 238 * Will be decremented for each raw event written. 239 * @pulse_width: Width of pulse in ns. 240 * @space_width: Width of space in ns. 241 * 242 * Returns: 0 on success. 243 * -ENOBUFS if there isn't enough buffer space to write both raw 244 * events. In this case @max events will have been written. 245 */ 246 static inline int ir_raw_gen_pulse_space(struct ir_raw_event **ev, 247 unsigned int *max, 248 unsigned int pulse_width, 249 unsigned int space_width) 250 { 251 if (!*max) 252 return -ENOBUFS; 253 init_ir_raw_event_duration((*ev)++, 1, pulse_width); 254 if (!--*max) 255 return -ENOBUFS; 256 init_ir_raw_event_duration((*ev)++, 0, space_width); 257 --*max; 258 return 0; 259 } 260 261 /** 262 * struct ir_raw_timings_pd - pulse-distance modulation timings 263 * @header_pulse: duration of header pulse in ns (0 for none) 264 * @header_space: duration of header space in ns 265 * @bit_pulse: duration of bit pulse in ns 266 * @bit_space: duration of bit space (for logic 0 and 1) in ns 267 * @trailer_pulse: duration of trailer pulse in ns 268 * @trailer_space: duration of trailer space in ns 269 * @msb_first: 1 if most significant bit is sent first 270 */ 271 struct ir_raw_timings_pd { 272 unsigned int header_pulse; 273 unsigned int header_space; 274 unsigned int bit_pulse; 275 unsigned int bit_space[2]; 276 unsigned int trailer_pulse; 277 unsigned int trailer_space; 278 unsigned int msb_first:1; 279 }; 280 281 int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max, 282 const struct ir_raw_timings_pd *timings, 283 unsigned int n, u64 data); 284 285 /** 286 * struct ir_raw_timings_pl - pulse-length modulation timings 287 * @header_pulse: duration of header pulse in ns (0 for none) 288 * @bit_space: duration of bit space in ns 289 * @bit_pulse: duration of bit pulse (for logic 0 and 1) in ns 290 * @trailer_space: duration of trailer space in ns 291 * @msb_first: 1 if most significant bit is sent first 292 */ 293 struct ir_raw_timings_pl { 294 unsigned int header_pulse; 295 unsigned int bit_space; 296 unsigned int bit_pulse[2]; 297 unsigned int trailer_space; 298 unsigned int msb_first:1; 299 }; 300 301 int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max, 302 const struct ir_raw_timings_pl *timings, 303 unsigned int n, u64 data); 304 305 /* 306 * Routines from rc-raw.c to be used internally and by decoders 307 */ 308 u64 ir_raw_get_allowed_protocols(void); 309 int ir_raw_event_prepare(struct rc_dev *dev); 310 int ir_raw_event_register(struct rc_dev *dev); 311 void ir_raw_event_free(struct rc_dev *dev); 312 void ir_raw_event_unregister(struct rc_dev *dev); 313 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler); 314 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler); 315 void ir_raw_load_modules(u64 *protocols); 316 void ir_raw_init(void); 317 318 /* 319 * lirc interface 320 */ 321 #ifdef CONFIG_LIRC 322 int lirc_dev_init(void); 323 void lirc_dev_exit(void); 324 void lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev); 325 void lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc); 326 int lirc_register(struct rc_dev *dev); 327 void lirc_unregister(struct rc_dev *dev); 328 struct rc_dev *rc_dev_get_from_fd(int fd); 329 #else 330 static inline int lirc_dev_init(void) { return 0; } 331 static inline void lirc_dev_exit(void) {} 332 static inline void lirc_raw_event(struct rc_dev *dev, 333 struct ir_raw_event ev) { } 334 static inline void lirc_scancode_event(struct rc_dev *dev, 335 struct lirc_scancode *lsc) { } 336 static inline int lirc_register(struct rc_dev *dev) { return 0; } 337 static inline void lirc_unregister(struct rc_dev *dev) { } 338 #endif 339 340 /* 341 * bpf interface 342 */ 343 #ifdef CONFIG_BPF_LIRC_MODE2 344 void lirc_bpf_free(struct rc_dev *dev); 345 void lirc_bpf_run(struct rc_dev *dev, u32 sample); 346 #else 347 static inline void lirc_bpf_free(struct rc_dev *dev) { } 348 static inline void lirc_bpf_run(struct rc_dev *dev, u32 sample) { } 349 #endif 350 351 #endif /* _RC_CORE_PRIV */ 352