1 /* 2 * SPDX-License-Identifier: GPL-2.0 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 struct nec_dec { 68 int state; 69 unsigned count; 70 u32 bits; 71 bool is_nec_x; 72 bool necx_repeat; 73 } nec; 74 struct rc5_dec { 75 int state; 76 u32 bits; 77 unsigned count; 78 bool is_rc5x; 79 } rc5; 80 struct rc6_dec { 81 int state; 82 u8 header; 83 u32 body; 84 bool toggle; 85 unsigned count; 86 unsigned wanted_bits; 87 } rc6; 88 struct sony_dec { 89 int state; 90 u32 bits; 91 unsigned count; 92 } sony; 93 struct jvc_dec { 94 int state; 95 u16 bits; 96 u16 old_bits; 97 unsigned count; 98 bool first; 99 bool toggle; 100 } jvc; 101 struct sanyo_dec { 102 int state; 103 unsigned count; 104 u64 bits; 105 } sanyo; 106 struct sharp_dec { 107 int state; 108 unsigned count; 109 u32 bits; 110 unsigned int pulse_len; 111 } sharp; 112 struct mce_kbd_dec { 113 struct input_dev *idev; 114 /* locks key up timer */ 115 spinlock_t keylock; 116 struct timer_list rx_timeout; 117 char name[64]; 118 char phys[64]; 119 int state; 120 u8 header; 121 u32 body; 122 unsigned count; 123 unsigned wanted_bits; 124 } mce_kbd; 125 struct xmp_dec { 126 int state; 127 unsigned count; 128 u32 durations[16]; 129 } xmp; 130 struct imon_dec { 131 int state; 132 int count; 133 int last_chk; 134 unsigned int bits; 135 bool stick_keyboard; 136 struct input_dev *idev; 137 char name[64]; 138 } imon; 139 }; 140 141 /* Mutex for locking raw IR processing and handler change */ 142 extern struct mutex ir_raw_handler_lock; 143 144 /* macros for IR decoders */ 145 static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin) 146 { 147 return d1 > (d2 - margin); 148 } 149 150 static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin) 151 { 152 return ((d1 > (d2 - margin)) && (d1 < (d2 + margin))); 153 } 154 155 static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y) 156 { 157 return x->pulse != y->pulse; 158 } 159 160 static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration) 161 { 162 if (duration > ev->duration) 163 ev->duration = 0; 164 else 165 ev->duration -= duration; 166 } 167 168 /* Returns true if event is normal pulse/space event */ 169 static inline bool is_timing_event(struct ir_raw_event ev) 170 { 171 return !ev.carrier_report && !ev.reset; 172 } 173 174 #define TO_US(duration) DIV_ROUND_CLOSEST((duration), 1000) 175 #define TO_STR(is_pulse) ((is_pulse) ? "pulse" : "space") 176 177 /* functions for IR encoders */ 178 bool rc_validate_scancode(enum rc_proto proto, u32 scancode); 179 180 static inline void init_ir_raw_event_duration(struct ir_raw_event *ev, 181 unsigned int pulse, 182 u32 duration) 183 { 184 init_ir_raw_event(ev); 185 ev->duration = duration; 186 ev->pulse = pulse; 187 } 188 189 /** 190 * struct ir_raw_timings_manchester - Manchester coding timings 191 * @leader_pulse: duration of leader pulse (if any) 0 if continuing 192 * existing signal 193 * @leader_space: duration of leader space (if any) 194 * @clock: duration of each pulse/space in ns 195 * @invert: if set clock logic is inverted 196 * (0 = space + pulse, 1 = pulse + space) 197 * @trailer_space: duration of trailer space in ns 198 */ 199 struct ir_raw_timings_manchester { 200 unsigned int leader_pulse; 201 unsigned int leader_space; 202 unsigned int clock; 203 unsigned int invert:1; 204 unsigned int trailer_space; 205 }; 206 207 int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max, 208 const struct ir_raw_timings_manchester *timings, 209 unsigned int n, u64 data); 210 211 /** 212 * ir_raw_gen_pulse_space() - generate pulse and space raw events. 213 * @ev: Pointer to pointer to next free raw event. 214 * Will be incremented for each raw event written. 215 * @max: Pointer to number of raw events available in buffer. 216 * Will be decremented for each raw event written. 217 * @pulse_width: Width of pulse in ns. 218 * @space_width: Width of space in ns. 219 * 220 * Returns: 0 on success. 221 * -ENOBUFS if there isn't enough buffer space to write both raw 222 * events. In this case @max events will have been written. 223 */ 224 static inline int ir_raw_gen_pulse_space(struct ir_raw_event **ev, 225 unsigned int *max, 226 unsigned int pulse_width, 227 unsigned int space_width) 228 { 229 if (!*max) 230 return -ENOBUFS; 231 init_ir_raw_event_duration((*ev)++, 1, pulse_width); 232 if (!--*max) 233 return -ENOBUFS; 234 init_ir_raw_event_duration((*ev)++, 0, space_width); 235 --*max; 236 return 0; 237 } 238 239 /** 240 * struct ir_raw_timings_pd - pulse-distance modulation timings 241 * @header_pulse: duration of header pulse in ns (0 for none) 242 * @header_space: duration of header space in ns 243 * @bit_pulse: duration of bit pulse in ns 244 * @bit_space: duration of bit space (for logic 0 and 1) in ns 245 * @trailer_pulse: duration of trailer pulse in ns 246 * @trailer_space: duration of trailer space in ns 247 * @msb_first: 1 if most significant bit is sent first 248 */ 249 struct ir_raw_timings_pd { 250 unsigned int header_pulse; 251 unsigned int header_space; 252 unsigned int bit_pulse; 253 unsigned int bit_space[2]; 254 unsigned int trailer_pulse; 255 unsigned int trailer_space; 256 unsigned int msb_first:1; 257 }; 258 259 int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max, 260 const struct ir_raw_timings_pd *timings, 261 unsigned int n, u64 data); 262 263 /** 264 * struct ir_raw_timings_pl - pulse-length modulation timings 265 * @header_pulse: duration of header pulse in ns (0 for none) 266 * @bit_space: duration of bit space in ns 267 * @bit_pulse: duration of bit pulse (for logic 0 and 1) 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_pl { 272 unsigned int header_pulse; 273 unsigned int bit_space; 274 unsigned int bit_pulse[2]; 275 unsigned int trailer_space; 276 unsigned int msb_first:1; 277 }; 278 279 int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max, 280 const struct ir_raw_timings_pl *timings, 281 unsigned int n, u64 data); 282 283 /* 284 * Routines from rc-raw.c to be used internally and by decoders 285 */ 286 u64 ir_raw_get_allowed_protocols(void); 287 int ir_raw_event_prepare(struct rc_dev *dev); 288 int ir_raw_event_register(struct rc_dev *dev); 289 void ir_raw_event_free(struct rc_dev *dev); 290 void ir_raw_event_unregister(struct rc_dev *dev); 291 int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler); 292 void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler); 293 void ir_raw_load_modules(u64 *protocols); 294 void ir_raw_init(void); 295 296 /* 297 * lirc interface 298 */ 299 #ifdef CONFIG_LIRC 300 int lirc_dev_init(void); 301 void lirc_dev_exit(void); 302 void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev); 303 void ir_lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc); 304 int ir_lirc_register(struct rc_dev *dev); 305 void ir_lirc_unregister(struct rc_dev *dev); 306 struct rc_dev *rc_dev_get_from_fd(int fd); 307 #else 308 static inline int lirc_dev_init(void) { return 0; } 309 static inline void lirc_dev_exit(void) {} 310 static inline void ir_lirc_raw_event(struct rc_dev *dev, 311 struct ir_raw_event ev) { } 312 static inline void ir_lirc_scancode_event(struct rc_dev *dev, 313 struct lirc_scancode *lsc) { } 314 static inline int ir_lirc_register(struct rc_dev *dev) { return 0; } 315 static inline void ir_lirc_unregister(struct rc_dev *dev) { } 316 #endif 317 318 /* 319 * bpf interface 320 */ 321 #ifdef CONFIG_BPF_LIRC_MODE2 322 void lirc_bpf_free(struct rc_dev *dev); 323 void lirc_bpf_run(struct rc_dev *dev, u32 sample); 324 #else 325 static inline void lirc_bpf_free(struct rc_dev *dev) { } 326 static inline void lirc_bpf_run(struct rc_dev *dev, u32 sample) { } 327 #endif 328 329 #endif /* _RC_CORE_PRIV */ 330