xref: /linux/drivers/media/rc/rc-core-priv.h (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
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 */
geq_margin(unsigned d1,unsigned d2,unsigned margin)167 static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
168 {
169 	return d1 > (d2 - margin);
170 }
171 
eq_margin(unsigned d1,unsigned d2,unsigned margin)172 static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
173 {
174 	return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
175 }
176 
is_transition(struct ir_raw_event * x,struct ir_raw_event * y)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 
decrease_duration(struct ir_raw_event * ev,unsigned duration)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 */
is_timing_event(struct ir_raw_event ev)191 static inline bool is_timing_event(struct ir_raw_event ev)
192 {
193 	return !ev.carrier_report && !ev.overflow;
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 
init_ir_raw_event_duration(struct ir_raw_event * ev,unsigned int pulse,u32 duration)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  */
ir_raw_gen_pulse_space(struct ir_raw_event ** ev,unsigned int * max,unsigned int pulse_width,unsigned int space_width)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, bool write);
329 #else
lirc_dev_init(void)330 static inline int lirc_dev_init(void) { return 0; }
lirc_dev_exit(void)331 static inline void lirc_dev_exit(void) {}
lirc_raw_event(struct rc_dev * dev,struct ir_raw_event ev)332 static inline void lirc_raw_event(struct rc_dev *dev,
333 				  struct ir_raw_event ev) { }
lirc_scancode_event(struct rc_dev * dev,struct lirc_scancode * lsc)334 static inline void lirc_scancode_event(struct rc_dev *dev,
335 				       struct lirc_scancode *lsc) { }
lirc_register(struct rc_dev * dev)336 static inline int lirc_register(struct rc_dev *dev) { return 0; }
lirc_unregister(struct rc_dev * dev)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
lirc_bpf_free(struct rc_dev * dev)347 static inline void lirc_bpf_free(struct rc_dev *dev) { }
lirc_bpf_run(struct rc_dev * dev,u32 sample)348 static inline void lirc_bpf_run(struct rc_dev *dev, u32 sample) { }
349 #endif
350 
351 #endif /* _RC_CORE_PRIV */
352