1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // ir-rc5-decoder.c - decoder for RC5(x) and StreamZap protocols |
3 | // |
4 | // Copyright (C) 2010 by Mauro Carvalho Chehab |
5 | // Copyright (C) 2010 by Jarod Wilson <jarod@redhat.com> |
6 | |
7 | /* |
8 | * This decoder handles the 14 bit RC5 protocol, 15 bit "StreamZap" protocol |
9 | * and 20 bit RC5x protocol. |
10 | */ |
11 | |
12 | #include "rc-core-priv.h" |
13 | #include <linux/module.h> |
14 | |
15 | #define RC5_NBITS 14 |
16 | #define RC5_SZ_NBITS 15 |
17 | #define RC5X_NBITS 20 |
18 | #define CHECK_RC5X_NBITS 8 |
19 | #define RC5_UNIT 889 /* us */ |
20 | #define RC5_BIT_START (1 * RC5_UNIT) |
21 | #define RC5_BIT_END (1 * RC5_UNIT) |
22 | #define RC5X_SPACE (4 * RC5_UNIT) |
23 | #define RC5_TRAILER (6 * RC5_UNIT) /* In reality, approx 100 */ |
24 | |
25 | enum rc5_state { |
26 | STATE_INACTIVE, |
27 | STATE_BIT_START, |
28 | STATE_BIT_END, |
29 | STATE_CHECK_RC5X, |
30 | STATE_FINISHED, |
31 | }; |
32 | |
33 | /** |
34 | * ir_rc5_decode() - Decode one RC-5 pulse or space |
35 | * @dev: the struct rc_dev descriptor of the device |
36 | * @ev: the struct ir_raw_event descriptor of the pulse/space |
37 | * |
38 | * This function returns -EINVAL if the pulse violates the state machine |
39 | */ |
40 | static int ir_rc5_decode(struct rc_dev *dev, struct ir_raw_event ev) |
41 | { |
42 | struct rc5_dec *data = &dev->raw->rc5; |
43 | u8 toggle; |
44 | u32 scancode; |
45 | enum rc_proto protocol; |
46 | |
47 | if (!is_timing_event(ev)) { |
48 | if (ev.overflow) |
49 | data->state = STATE_INACTIVE; |
50 | return 0; |
51 | } |
52 | |
53 | if (!geq_margin(d1: ev.duration, RC5_UNIT, RC5_UNIT / 2)) |
54 | goto out; |
55 | |
56 | again: |
57 | dev_dbg(&dev->dev, "RC5(x/sz) decode started at state %i (%uus %s)\n" , |
58 | data->state, ev.duration, TO_STR(ev.pulse)); |
59 | |
60 | if (!geq_margin(d1: ev.duration, RC5_UNIT, RC5_UNIT / 2)) |
61 | return 0; |
62 | |
63 | switch (data->state) { |
64 | |
65 | case STATE_INACTIVE: |
66 | if (!ev.pulse) |
67 | break; |
68 | |
69 | data->state = STATE_BIT_START; |
70 | data->count = 1; |
71 | decrease_duration(ev: &ev, RC5_BIT_START); |
72 | goto again; |
73 | |
74 | case STATE_BIT_START: |
75 | if (!ev.pulse && geq_margin(d1: ev.duration, RC5_TRAILER, RC5_UNIT / 2)) { |
76 | data->state = STATE_FINISHED; |
77 | goto again; |
78 | } |
79 | |
80 | if (!eq_margin(d1: ev.duration, RC5_BIT_START, RC5_UNIT / 2)) |
81 | break; |
82 | |
83 | data->bits <<= 1; |
84 | if (!ev.pulse) |
85 | data->bits |= 1; |
86 | data->count++; |
87 | data->state = STATE_BIT_END; |
88 | return 0; |
89 | |
90 | case STATE_BIT_END: |
91 | if (data->count == CHECK_RC5X_NBITS) |
92 | data->state = STATE_CHECK_RC5X; |
93 | else |
94 | data->state = STATE_BIT_START; |
95 | |
96 | decrease_duration(ev: &ev, RC5_BIT_END); |
97 | goto again; |
98 | |
99 | case STATE_CHECK_RC5X: |
100 | if (!ev.pulse && geq_margin(d1: ev.duration, RC5X_SPACE, RC5_UNIT / 2)) { |
101 | data->is_rc5x = true; |
102 | decrease_duration(ev: &ev, RC5X_SPACE); |
103 | } else |
104 | data->is_rc5x = false; |
105 | data->state = STATE_BIT_START; |
106 | goto again; |
107 | |
108 | case STATE_FINISHED: |
109 | if (ev.pulse) |
110 | break; |
111 | |
112 | if (data->is_rc5x && data->count == RC5X_NBITS) { |
113 | /* RC5X */ |
114 | u8 xdata, command, system; |
115 | if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5X_20)) { |
116 | data->state = STATE_INACTIVE; |
117 | return 0; |
118 | } |
119 | xdata = (data->bits & 0x0003F) >> 0; |
120 | command = (data->bits & 0x00FC0) >> 6; |
121 | system = (data->bits & 0x1F000) >> 12; |
122 | toggle = (data->bits & 0x20000) ? 1 : 0; |
123 | command += (data->bits & 0x40000) ? 0 : 0x40; |
124 | scancode = system << 16 | command << 8 | xdata; |
125 | protocol = RC_PROTO_RC5X_20; |
126 | |
127 | } else if (!data->is_rc5x && data->count == RC5_NBITS) { |
128 | /* RC5 */ |
129 | u8 command, system; |
130 | if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5)) { |
131 | data->state = STATE_INACTIVE; |
132 | return 0; |
133 | } |
134 | command = (data->bits & 0x0003F) >> 0; |
135 | system = (data->bits & 0x007C0) >> 6; |
136 | toggle = (data->bits & 0x00800) ? 1 : 0; |
137 | command += (data->bits & 0x01000) ? 0 : 0x40; |
138 | scancode = system << 8 | command; |
139 | protocol = RC_PROTO_RC5; |
140 | |
141 | } else if (!data->is_rc5x && data->count == RC5_SZ_NBITS) { |
142 | /* RC5 StreamZap */ |
143 | u8 command, system; |
144 | if (!(dev->enabled_protocols & RC_PROTO_BIT_RC5_SZ)) { |
145 | data->state = STATE_INACTIVE; |
146 | return 0; |
147 | } |
148 | command = (data->bits & 0x0003F) >> 0; |
149 | system = (data->bits & 0x02FC0) >> 6; |
150 | toggle = (data->bits & 0x01000) ? 1 : 0; |
151 | scancode = system << 6 | command; |
152 | protocol = RC_PROTO_RC5_SZ; |
153 | |
154 | } else |
155 | break; |
156 | |
157 | dev_dbg(&dev->dev, "RC5(x/sz) scancode 0x%06x (p: %u, t: %u)\n" , |
158 | scancode, protocol, toggle); |
159 | |
160 | rc_keydown(dev, protocol, scancode, toggle); |
161 | data->state = STATE_INACTIVE; |
162 | return 0; |
163 | } |
164 | |
165 | out: |
166 | dev_dbg(&dev->dev, "RC5(x/sz) decode failed at state %i count %d (%uus %s)\n" , |
167 | data->state, data->count, ev.duration, TO_STR(ev.pulse)); |
168 | data->state = STATE_INACTIVE; |
169 | return -EINVAL; |
170 | } |
171 | |
172 | static const struct ir_raw_timings_manchester ir_rc5_timings = { |
173 | .leader_pulse = RC5_UNIT, |
174 | .clock = RC5_UNIT, |
175 | .trailer_space = RC5_UNIT * 10, |
176 | }; |
177 | |
178 | static const struct ir_raw_timings_manchester ir_rc5x_timings[2] = { |
179 | { |
180 | .leader_pulse = RC5_UNIT, |
181 | .clock = RC5_UNIT, |
182 | .trailer_space = RC5X_SPACE, |
183 | }, |
184 | { |
185 | .clock = RC5_UNIT, |
186 | .trailer_space = RC5_UNIT * 10, |
187 | }, |
188 | }; |
189 | |
190 | static const struct ir_raw_timings_manchester ir_rc5_sz_timings = { |
191 | .leader_pulse = RC5_UNIT, |
192 | .clock = RC5_UNIT, |
193 | .trailer_space = RC5_UNIT * 10, |
194 | }; |
195 | |
196 | /** |
197 | * ir_rc5_encode() - Encode a scancode as a stream of raw events |
198 | * |
199 | * @protocol: protocol variant to encode |
200 | * @scancode: scancode to encode |
201 | * @events: array of raw ir events to write into |
202 | * @max: maximum size of @events |
203 | * |
204 | * Returns: The number of events written. |
205 | * -ENOBUFS if there isn't enough space in the array to fit the |
206 | * encoding. In this case all @max events will have been written. |
207 | * -EINVAL if the scancode is ambiguous or invalid. |
208 | */ |
209 | static int ir_rc5_encode(enum rc_proto protocol, u32 scancode, |
210 | struct ir_raw_event *events, unsigned int max) |
211 | { |
212 | int ret; |
213 | struct ir_raw_event *e = events; |
214 | unsigned int data, xdata, command, commandx, system, pre_space_data; |
215 | |
216 | /* Detect protocol and convert scancode to raw data */ |
217 | if (protocol == RC_PROTO_RC5) { |
218 | /* decode scancode */ |
219 | command = (scancode & 0x003f) >> 0; |
220 | commandx = (scancode & 0x0040) >> 6; |
221 | system = (scancode & 0x1f00) >> 8; |
222 | /* encode data */ |
223 | data = !commandx << 12 | system << 6 | command; |
224 | |
225 | /* First bit is encoded by leader_pulse */ |
226 | ret = ir_raw_gen_manchester(ev: &e, max, timings: &ir_rc5_timings, |
227 | RC5_NBITS - 1, data); |
228 | if (ret < 0) |
229 | return ret; |
230 | } else if (protocol == RC_PROTO_RC5X_20) { |
231 | /* decode scancode */ |
232 | xdata = (scancode & 0x00003f) >> 0; |
233 | command = (scancode & 0x003f00) >> 8; |
234 | commandx = !(scancode & 0x004000); |
235 | system = (scancode & 0x1f0000) >> 16; |
236 | |
237 | /* encode data */ |
238 | data = commandx << 18 | system << 12 | command << 6 | xdata; |
239 | |
240 | /* First bit is encoded by leader_pulse */ |
241 | pre_space_data = data >> (RC5X_NBITS - CHECK_RC5X_NBITS); |
242 | ret = ir_raw_gen_manchester(ev: &e, max, timings: &ir_rc5x_timings[0], |
243 | CHECK_RC5X_NBITS - 1, |
244 | data: pre_space_data); |
245 | if (ret < 0) |
246 | return ret; |
247 | ret = ir_raw_gen_manchester(ev: &e, max: max - (e - events), |
248 | timings: &ir_rc5x_timings[1], |
249 | RC5X_NBITS - CHECK_RC5X_NBITS, |
250 | data); |
251 | if (ret < 0) |
252 | return ret; |
253 | } else if (protocol == RC_PROTO_RC5_SZ) { |
254 | /* RC5-SZ scancode is raw enough for Manchester as it is */ |
255 | /* First bit is encoded by leader_pulse */ |
256 | ret = ir_raw_gen_manchester(ev: &e, max, timings: &ir_rc5_sz_timings, |
257 | RC5_SZ_NBITS - 1, |
258 | data: scancode & 0x2fff); |
259 | if (ret < 0) |
260 | return ret; |
261 | } else { |
262 | return -EINVAL; |
263 | } |
264 | |
265 | return e - events; |
266 | } |
267 | |
268 | static struct ir_raw_handler rc5_handler = { |
269 | .protocols = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC5X_20 | |
270 | RC_PROTO_BIT_RC5_SZ, |
271 | .decode = ir_rc5_decode, |
272 | .encode = ir_rc5_encode, |
273 | .carrier = 36000, |
274 | .min_timeout = RC5_TRAILER, |
275 | }; |
276 | |
277 | static int __init ir_rc5_decode_init(void) |
278 | { |
279 | ir_raw_handler_register(ir_raw_handler: &rc5_handler); |
280 | |
281 | printk(KERN_INFO "IR RC5(x/sz) protocol handler initialized\n" ); |
282 | return 0; |
283 | } |
284 | |
285 | static void __exit ir_rc5_decode_exit(void) |
286 | { |
287 | ir_raw_handler_unregister(ir_raw_handler: &rc5_handler); |
288 | } |
289 | |
290 | module_init(ir_rc5_decode_init); |
291 | module_exit(ir_rc5_decode_exit); |
292 | |
293 | MODULE_LICENSE("GPL v2" ); |
294 | MODULE_AUTHOR("Mauro Carvalho Chehab and Jarod Wilson" ); |
295 | MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)" ); |
296 | MODULE_DESCRIPTION("RC5(x/sz) IR protocol decoder" ); |
297 | |