1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
2 | /* |
3 | * Remote Controller core header |
4 | * |
5 | * Copyright (C) 2009-2010 by Mauro Carvalho Chehab |
6 | */ |
7 | |
8 | #ifndef _RC_CORE |
9 | #define _RC_CORE |
10 | |
11 | #include <linux/spinlock.h> |
12 | #include <linux/cdev.h> |
13 | #include <linux/kfifo.h> |
14 | #include <linux/time.h> |
15 | #include <linux/timer.h> |
16 | #include <media/rc-map.h> |
17 | |
18 | /** |
19 | * enum rc_driver_type - type of the RC driver. |
20 | * |
21 | * @RC_DRIVER_SCANCODE: Driver or hardware generates a scancode. |
22 | * @RC_DRIVER_IR_RAW: Driver or hardware generates pulse/space sequences. |
23 | * It needs a Infra-Red pulse/space decoder |
24 | * @RC_DRIVER_IR_RAW_TX: Device transmitter only, |
25 | * driver requires pulse/space data sequence. |
26 | */ |
27 | enum rc_driver_type { |
28 | RC_DRIVER_SCANCODE = 0, |
29 | RC_DRIVER_IR_RAW, |
30 | RC_DRIVER_IR_RAW_TX, |
31 | }; |
32 | |
33 | /** |
34 | * struct rc_scancode_filter - Filter scan codes. |
35 | * @data: Scancode data to match. |
36 | * @mask: Mask of bits of scancode to compare. |
37 | */ |
38 | struct rc_scancode_filter { |
39 | u32 data; |
40 | u32 mask; |
41 | }; |
42 | |
43 | /** |
44 | * enum rc_filter_type - Filter type constants. |
45 | * @RC_FILTER_NORMAL: Filter for normal operation. |
46 | * @RC_FILTER_WAKEUP: Filter for waking from suspend. |
47 | * @RC_FILTER_MAX: Number of filter types. |
48 | */ |
49 | enum rc_filter_type { |
50 | RC_FILTER_NORMAL = 0, |
51 | RC_FILTER_WAKEUP, |
52 | |
53 | RC_FILTER_MAX |
54 | }; |
55 | |
56 | /** |
57 | * struct lirc_fh - represents an open lirc file |
58 | * @list: list of open file handles |
59 | * @rc: rcdev for this lirc chardev |
60 | * @carrier_low: when setting the carrier range, first the low end must be |
61 | * set with an ioctl and then the high end with another ioctl |
62 | * @rawir: queue for incoming raw IR |
63 | * @scancodes: queue for incoming decoded scancodes |
64 | * @wait_poll: poll struct for lirc device |
65 | * @send_mode: lirc mode for sending, either LIRC_MODE_SCANCODE or |
66 | * LIRC_MODE_PULSE |
67 | * @rec_mode: lirc mode for receiving, either LIRC_MODE_SCANCODE or |
68 | * LIRC_MODE_MODE2 |
69 | */ |
70 | struct lirc_fh { |
71 | struct list_head list; |
72 | struct rc_dev *rc; |
73 | int carrier_low; |
74 | DECLARE_KFIFO_PTR(rawir, unsigned int); |
75 | DECLARE_KFIFO_PTR(scancodes, struct lirc_scancode); |
76 | wait_queue_head_t wait_poll; |
77 | u8 send_mode; |
78 | u8 rec_mode; |
79 | }; |
80 | |
81 | /** |
82 | * struct rc_dev - represents a remote control device |
83 | * @dev: driver model's view of this device |
84 | * @managed_alloc: devm_rc_allocate_device was used to create rc_dev |
85 | * @sysfs_groups: sysfs attribute groups |
86 | * @device_name: name of the rc child device |
87 | * @input_phys: physical path to the input child device |
88 | * @input_id: id of the input child device (struct input_id) |
89 | * @driver_name: name of the hardware driver which registered this device |
90 | * @map_name: name of the default keymap |
91 | * @rc_map: current scan/key table |
92 | * @lock: used to ensure we've filled in all protocol details before |
93 | * anyone can call show_protocols or store_protocols |
94 | * @minor: unique minor remote control device number |
95 | * @raw: additional data for raw pulse/space devices |
96 | * @input_dev: the input child device used to communicate events to userspace |
97 | * @driver_type: specifies if protocol decoding is done in hardware or software |
98 | * @idle: used to keep track of RX state |
99 | * @encode_wakeup: wakeup filtering uses IR encode API, therefore the allowed |
100 | * wakeup protocols is the set of all raw encoders |
101 | * @allowed_protocols: bitmask with the supported RC_PROTO_BIT_* protocols |
102 | * @enabled_protocols: bitmask with the enabled RC_PROTO_BIT_* protocols |
103 | * @allowed_wakeup_protocols: bitmask with the supported RC_PROTO_BIT_* wakeup |
104 | * protocols |
105 | * @wakeup_protocol: the enabled RC_PROTO_* wakeup protocol or |
106 | * RC_PROTO_UNKNOWN if disabled. |
107 | * @scancode_filter: scancode filter |
108 | * @scancode_wakeup_filter: scancode wakeup filters |
109 | * @scancode_mask: some hardware decoders are not capable of providing the full |
110 | * scancode to the application. As this is a hardware limit, we can't do |
111 | * anything with it. Yet, as the same keycode table can be used with other |
112 | * devices, a mask is provided to allow its usage. Drivers should generally |
113 | * leave this field in blank |
114 | * @users: number of current users of the device |
115 | * @priv: driver-specific data |
116 | * @keylock: protects the remaining members of the struct |
117 | * @keypressed: whether a key is currently pressed |
118 | * @keyup_jiffies: time (in jiffies) when the current keypress should be released |
119 | * @timer_keyup: timer for releasing a keypress |
120 | * @timer_repeat: timer for autorepeat events. This is needed for CEC, which |
121 | * has non-standard repeats. |
122 | * @last_keycode: keycode of last keypress |
123 | * @last_protocol: protocol of last keypress |
124 | * @last_scancode: scancode of last keypress |
125 | * @last_toggle: toggle value of last command |
126 | * @timeout: optional time after which device stops sending data |
127 | * @min_timeout: minimum timeout supported by device |
128 | * @max_timeout: maximum timeout supported by device |
129 | * @rx_resolution : resolution (in us) of input sampler |
130 | * @tx_resolution: resolution (in us) of output sampler |
131 | * @lirc_dev: lirc device |
132 | * @lirc_cdev: lirc char cdev |
133 | * @gap_start: start time for gap after timeout if non-zero |
134 | * @lirc_fh_lock: protects lirc_fh list |
135 | * @lirc_fh: list of open files |
136 | * @registered: set to true by rc_register_device(), false by |
137 | * rc_unregister_device |
138 | * @change_protocol: allow changing the protocol used on hardware decoders |
139 | * @open: callback to allow drivers to enable polling/irq when IR input device |
140 | * is opened. |
141 | * @close: callback to allow drivers to disable polling/irq when IR input device |
142 | * is opened. |
143 | * @s_tx_mask: set transmitter mask (for devices with multiple tx outputs) |
144 | * @s_tx_carrier: set transmit carrier frequency |
145 | * @s_tx_duty_cycle: set transmit duty cycle (0% - 100%) |
146 | * @s_rx_carrier_range: inform driver about carrier it is expected to handle |
147 | * @tx_ir: transmit IR |
148 | * @s_idle: enable/disable hardware idle mode, upon which, |
149 | * device doesn't interrupt host until it sees IR pulses |
150 | * @s_wideband_receiver: enable wide band receiver used for learning |
151 | * @s_carrier_report: enable carrier reports |
152 | * @s_filter: set the scancode filter |
153 | * @s_wakeup_filter: set the wakeup scancode filter. If the mask is zero |
154 | * then wakeup should be disabled. wakeup_protocol will be set to |
155 | * a valid protocol if mask is nonzero. |
156 | * @s_timeout: set hardware timeout in us |
157 | */ |
158 | struct rc_dev { |
159 | struct device dev; |
160 | bool managed_alloc; |
161 | const struct attribute_group *sysfs_groups[5]; |
162 | const char *device_name; |
163 | const char *input_phys; |
164 | struct input_id input_id; |
165 | const char *driver_name; |
166 | const char *map_name; |
167 | struct rc_map rc_map; |
168 | struct mutex lock; |
169 | unsigned int minor; |
170 | struct ir_raw_event_ctrl *raw; |
171 | struct input_dev *input_dev; |
172 | enum rc_driver_type driver_type; |
173 | bool idle; |
174 | bool encode_wakeup; |
175 | u64 allowed_protocols; |
176 | u64 enabled_protocols; |
177 | u64 allowed_wakeup_protocols; |
178 | enum rc_proto wakeup_protocol; |
179 | struct rc_scancode_filter scancode_filter; |
180 | struct rc_scancode_filter scancode_wakeup_filter; |
181 | u32 scancode_mask; |
182 | u32 users; |
183 | void *priv; |
184 | spinlock_t keylock; |
185 | bool keypressed; |
186 | unsigned long keyup_jiffies; |
187 | struct timer_list timer_keyup; |
188 | struct timer_list timer_repeat; |
189 | u32 last_keycode; |
190 | enum rc_proto last_protocol; |
191 | u64 last_scancode; |
192 | u8 last_toggle; |
193 | u32 timeout; |
194 | u32 min_timeout; |
195 | u32 max_timeout; |
196 | u32 rx_resolution; |
197 | u32 tx_resolution; |
198 | #ifdef CONFIG_LIRC |
199 | struct device lirc_dev; |
200 | struct cdev lirc_cdev; |
201 | ktime_t gap_start; |
202 | spinlock_t lirc_fh_lock; |
203 | struct list_head lirc_fh; |
204 | #endif |
205 | bool registered; |
206 | int (*change_protocol)(struct rc_dev *dev, u64 *rc_proto); |
207 | int (*open)(struct rc_dev *dev); |
208 | void (*close)(struct rc_dev *dev); |
209 | int (*s_tx_mask)(struct rc_dev *dev, u32 mask); |
210 | int (*s_tx_carrier)(struct rc_dev *dev, u32 carrier); |
211 | int (*s_tx_duty_cycle)(struct rc_dev *dev, u32 duty_cycle); |
212 | int (*s_rx_carrier_range)(struct rc_dev *dev, u32 min, u32 max); |
213 | int (*tx_ir)(struct rc_dev *dev, unsigned *txbuf, unsigned n); |
214 | void (*s_idle)(struct rc_dev *dev, bool enable); |
215 | int (*s_wideband_receiver)(struct rc_dev *dev, int enable); |
216 | int (*s_carrier_report) (struct rc_dev *dev, int enable); |
217 | int (*s_filter)(struct rc_dev *dev, |
218 | struct rc_scancode_filter *filter); |
219 | int (*s_wakeup_filter)(struct rc_dev *dev, |
220 | struct rc_scancode_filter *filter); |
221 | int (*s_timeout)(struct rc_dev *dev, |
222 | unsigned int timeout); |
223 | }; |
224 | |
225 | #define to_rc_dev(d) container_of(d, struct rc_dev, dev) |
226 | |
227 | /* |
228 | * From rc-main.c |
229 | * Those functions can be used on any type of Remote Controller. They |
230 | * basically creates an input_dev and properly reports the device as a |
231 | * Remote Controller, at sys/class/rc. |
232 | */ |
233 | |
234 | /** |
235 | * rc_allocate_device - Allocates a RC device |
236 | * |
237 | * @rc_driver_type: specifies the type of the RC output to be allocated |
238 | * returns a pointer to struct rc_dev. |
239 | */ |
240 | struct rc_dev *rc_allocate_device(enum rc_driver_type); |
241 | |
242 | /** |
243 | * devm_rc_allocate_device - Managed RC device allocation |
244 | * |
245 | * @dev: pointer to struct device |
246 | * @rc_driver_type: specifies the type of the RC output to be allocated |
247 | * returns a pointer to struct rc_dev. |
248 | */ |
249 | struct rc_dev *devm_rc_allocate_device(struct device *dev, enum rc_driver_type); |
250 | |
251 | /** |
252 | * rc_free_device - Frees a RC device |
253 | * |
254 | * @dev: pointer to struct rc_dev. |
255 | */ |
256 | void rc_free_device(struct rc_dev *dev); |
257 | |
258 | /** |
259 | * rc_register_device - Registers a RC device |
260 | * |
261 | * @dev: pointer to struct rc_dev. |
262 | */ |
263 | int rc_register_device(struct rc_dev *dev); |
264 | |
265 | /** |
266 | * devm_rc_register_device - Manageded registering of a RC device |
267 | * |
268 | * @parent: pointer to struct device. |
269 | * @dev: pointer to struct rc_dev. |
270 | */ |
271 | int devm_rc_register_device(struct device *parent, struct rc_dev *dev); |
272 | |
273 | /** |
274 | * rc_unregister_device - Unregisters a RC device |
275 | * |
276 | * @dev: pointer to struct rc_dev. |
277 | */ |
278 | void rc_unregister_device(struct rc_dev *dev); |
279 | |
280 | void rc_repeat(struct rc_dev *dev); |
281 | void rc_keydown(struct rc_dev *dev, enum rc_proto protocol, u64 scancode, |
282 | u8 toggle); |
283 | void rc_keydown_notimeout(struct rc_dev *dev, enum rc_proto protocol, |
284 | u64 scancode, u8 toggle); |
285 | void rc_keyup(struct rc_dev *dev); |
286 | u32 rc_g_keycode_from_table(struct rc_dev *dev, u64 scancode); |
287 | |
288 | /* |
289 | * From rc-raw.c |
290 | * The Raw interface is specific to InfraRed. It may be a good idea to |
291 | * split it later into a separate header. |
292 | */ |
293 | struct ir_raw_event { |
294 | union { |
295 | u32 duration; |
296 | u32 carrier; |
297 | }; |
298 | u8 duty_cycle; |
299 | |
300 | unsigned pulse:1; |
301 | unsigned overflow:1; |
302 | unsigned timeout:1; |
303 | unsigned carrier_report:1; |
304 | }; |
305 | |
306 | #define US_TO_NS(usec) ((usec) * 1000) |
307 | #define MS_TO_US(msec) ((msec) * 1000) |
308 | #define IR_MAX_DURATION MS_TO_US(500) |
309 | #define IR_DEFAULT_TIMEOUT MS_TO_US(125) |
310 | #define IR_MAX_TIMEOUT LIRC_VALUE_MASK |
311 | |
312 | void ir_raw_event_handle(struct rc_dev *dev); |
313 | int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev); |
314 | int ir_raw_event_store_edge(struct rc_dev *dev, bool pulse); |
315 | int ir_raw_event_store_with_filter(struct rc_dev *dev, |
316 | struct ir_raw_event *ev); |
317 | int ir_raw_event_store_with_timeout(struct rc_dev *dev, |
318 | struct ir_raw_event *ev); |
319 | void ir_raw_event_set_idle(struct rc_dev *dev, bool idle); |
320 | int ir_raw_encode_scancode(enum rc_proto protocol, u32 scancode, |
321 | struct ir_raw_event *events, unsigned int max); |
322 | int ir_raw_encode_carrier(enum rc_proto protocol); |
323 | |
324 | static inline void ir_raw_event_overflow(struct rc_dev *dev) |
325 | { |
326 | ir_raw_event_store(dev, ev: &((struct ir_raw_event) { .overflow = true })); |
327 | dev->idle = true; |
328 | ir_raw_event_handle(dev); |
329 | } |
330 | |
331 | /* extract mask bits out of data and pack them into the result */ |
332 | static inline u32 (u32 data, u32 mask) |
333 | { |
334 | u32 vbit = 1, value = 0; |
335 | |
336 | do { |
337 | if (mask & 1) { |
338 | if (data & 1) |
339 | value |= vbit; |
340 | vbit <<= 1; |
341 | } |
342 | data >>= 1; |
343 | } while (mask >>= 1); |
344 | |
345 | return value; |
346 | } |
347 | |
348 | /* Get NEC scancode and protocol type from address and command bytes */ |
349 | static inline u32 ir_nec_bytes_to_scancode(u8 address, u8 not_address, |
350 | u8 command, u8 not_command, |
351 | enum rc_proto *protocol) |
352 | { |
353 | u32 scancode; |
354 | |
355 | if ((command ^ not_command) != 0xff) { |
356 | /* NEC transport, but modified protocol, used by at |
357 | * least Apple and TiVo remotes |
358 | */ |
359 | scancode = not_address << 24 | |
360 | address << 16 | |
361 | not_command << 8 | |
362 | command; |
363 | *protocol = RC_PROTO_NEC32; |
364 | } else if ((address ^ not_address) != 0xff) { |
365 | /* Extended NEC */ |
366 | scancode = address << 16 | |
367 | not_address << 8 | |
368 | command; |
369 | *protocol = RC_PROTO_NECX; |
370 | } else { |
371 | /* Normal NEC */ |
372 | scancode = address << 8 | command; |
373 | *protocol = RC_PROTO_NEC; |
374 | } |
375 | |
376 | return scancode; |
377 | } |
378 | |
379 | #endif /* _RC_CORE */ |
380 | |