Commit | Line | Data |
---|---|---|
784a4931 DH |
1 | /* ir-rc6-decoder.c - A decoder for the RC6 IR protocol |
2 | * | |
3 | * Copyright (C) 2010 by David Härdeman <david@hardeman.nu> | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation version 2 of the License. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | */ | |
14 | ||
f62de675 | 15 | #include "rc-core-priv.h" |
7a707b89 | 16 | #include <linux/module.h> |
784a4931 DH |
17 | |
18 | /* | |
19 | * This decoder currently supports: | |
20 | * RC6-0-16 (standard toggle bit in header) | |
db9bc660 | 21 | * RC6-6A-20 (no toggle bit) |
784a4931 DH |
22 | * RC6-6A-24 (no toggle bit) |
23 | * RC6-6A-32 (MCE version with toggle bit in body) | |
24 | */ | |
25 | ||
db9bc660 | 26 | #define RC6_UNIT 444444 /* nanosecs */ |
784a4931 DH |
27 | #define RC6_HEADER_NBITS 4 /* not including toggle bit */ |
28 | #define RC6_0_NBITS 16 | |
db9bc660 | 29 | #define RC6_6A_32_NBITS 32 |
30 | #define RC6_6A_NBITS 128 /* Variable 8..128 */ | |
e40b1127 DH |
31 | #define RC6_PREFIX_PULSE (6 * RC6_UNIT) |
32 | #define RC6_PREFIX_SPACE (2 * RC6_UNIT) | |
33 | #define RC6_BIT_START (1 * RC6_UNIT) | |
34 | #define RC6_BIT_END (1 * RC6_UNIT) | |
35 | #define RC6_TOGGLE_START (2 * RC6_UNIT) | |
36 | #define RC6_TOGGLE_END (2 * RC6_UNIT) | |
db9bc660 | 37 | #define RC6_SUFFIX_SPACE (6 * RC6_UNIT) |
784a4931 DH |
38 | #define RC6_MODE_MASK 0x07 /* for the header bits */ |
39 | #define RC6_STARTBIT_MASK 0x08 /* for the header bits */ | |
40 | #define RC6_6A_MCE_TOGGLE_MASK 0x8000 /* for the body bits */ | |
db9bc660 | 41 | #define RC6_6A_LCC_MASK 0xffff0000 /* RC6-6A-32 long customer code mask */ |
42 | #define RC6_6A_MCE_CC 0x800f0000 /* MCE customer code */ | |
43 | #ifndef CHAR_BIT | |
44 | #define CHAR_BIT 8 /* Normally in <limits.h> */ | |
45 | #endif | |
784a4931 | 46 | |
784a4931 DH |
47 | enum rc6_mode { |
48 | RC6_MODE_0, | |
49 | RC6_MODE_6A, | |
50 | RC6_MODE_UNKNOWN, | |
51 | }; | |
52 | ||
53 | enum rc6_state { | |
54 | STATE_INACTIVE, | |
55 | STATE_PREFIX_SPACE, | |
56 | STATE_HEADER_BIT_START, | |
57 | STATE_HEADER_BIT_END, | |
58 | STATE_TOGGLE_START, | |
59 | STATE_TOGGLE_END, | |
60 | STATE_BODY_BIT_START, | |
61 | STATE_BODY_BIT_END, | |
62 | STATE_FINISHED, | |
63 | }; | |
64 | ||
c216369e | 65 | static enum rc6_mode rc6_mode(struct rc6_dec *data) |
784a4931 | 66 | { |
784a4931 DH |
67 | switch (data->header & RC6_MODE_MASK) { |
68 | case 0: | |
69 | return RC6_MODE_0; | |
70 | case 6: | |
71 | if (!data->toggle) | |
72 | return RC6_MODE_6A; | |
73 | /* fall through */ | |
74 | default: | |
75 | return RC6_MODE_UNKNOWN; | |
76 | } | |
77 | } | |
78 | ||
79 | /** | |
80 | * ir_rc6_decode() - Decode one RC6 pulse or space | |
d8b4b582 | 81 | * @dev: the struct rc_dev descriptor of the device |
e40b1127 | 82 | * @ev: the struct ir_raw_event descriptor of the pulse/space |
784a4931 DH |
83 | * |
84 | * This function returns -EINVAL if the pulse violates the state machine | |
85 | */ | |
d8b4b582 | 86 | static int ir_rc6_decode(struct rc_dev *dev, struct ir_raw_event ev) |
784a4931 | 87 | { |
d8b4b582 | 88 | struct rc6_dec *data = &dev->raw->rc6; |
784a4931 DH |
89 | u32 scancode; |
90 | u8 toggle; | |
120703f9 | 91 | enum rc_type protocol; |
784a4931 | 92 | |
c5540fbb DH |
93 | if (!(dev->enabled_protocols & |
94 | (RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 | RC_BIT_RC6_6A_24 | | |
95 | RC_BIT_RC6_6A_32 | RC_BIT_RC6_MCE))) | |
784a4931 DH |
96 | return 0; |
97 | ||
4651918a ML |
98 | if (!is_timing_event(ev)) { |
99 | if (ev.reset) | |
100 | data->state = STATE_INACTIVE; | |
784a4931 DH |
101 | return 0; |
102 | } | |
103 | ||
e40b1127 | 104 | if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2)) |
784a4931 DH |
105 | goto out; |
106 | ||
107 | again: | |
e40b1127 DH |
108 | IR_dprintk(2, "RC6 decode started at state %i (%uus %s)\n", |
109 | data->state, TO_US(ev.duration), TO_STR(ev.pulse)); | |
784a4931 | 110 | |
e40b1127 | 111 | if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2)) |
784a4931 DH |
112 | return 0; |
113 | ||
114 | switch (data->state) { | |
115 | ||
116 | case STATE_INACTIVE: | |
e40b1127 DH |
117 | if (!ev.pulse) |
118 | break; | |
119 | ||
120 | /* Note: larger margin on first pulse since each RC6_UNIT | |
121 | is quite short and some hardware takes some time to | |
122 | adjust to the signal */ | |
123 | if (!eq_margin(ev.duration, RC6_PREFIX_PULSE, RC6_UNIT)) | |
124 | break; | |
125 | ||
126 | data->state = STATE_PREFIX_SPACE; | |
127 | data->count = 0; | |
128 | return 0; | |
784a4931 DH |
129 | |
130 | case STATE_PREFIX_SPACE: | |
e40b1127 DH |
131 | if (ev.pulse) |
132 | break; | |
133 | ||
134 | if (!eq_margin(ev.duration, RC6_PREFIX_SPACE, RC6_UNIT / 2)) | |
135 | break; | |
136 | ||
137 | data->state = STATE_HEADER_BIT_START; | |
db9bc660 | 138 | data->header = 0; |
e40b1127 | 139 | return 0; |
784a4931 DH |
140 | |
141 | case STATE_HEADER_BIT_START: | |
e40b1127 DH |
142 | if (!eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2)) |
143 | break; | |
144 | ||
145 | data->header <<= 1; | |
146 | if (ev.pulse) | |
147 | data->header |= 1; | |
148 | data->count++; | |
e40b1127 DH |
149 | data->state = STATE_HEADER_BIT_END; |
150 | return 0; | |
784a4931 DH |
151 | |
152 | case STATE_HEADER_BIT_END: | |
d8b4b582 | 153 | if (!is_transition(&ev, &dev->raw->prev_ev)) |
e40b1127 | 154 | break; |
784a4931 | 155 | |
e40b1127 DH |
156 | if (data->count == RC6_HEADER_NBITS) |
157 | data->state = STATE_TOGGLE_START; | |
158 | else | |
159 | data->state = STATE_HEADER_BIT_START; | |
160 | ||
161 | decrease_duration(&ev, RC6_BIT_END); | |
162 | goto again; | |
784a4931 DH |
163 | |
164 | case STATE_TOGGLE_START: | |
e40b1127 DH |
165 | if (!eq_margin(ev.duration, RC6_TOGGLE_START, RC6_UNIT / 2)) |
166 | break; | |
167 | ||
168 | data->toggle = ev.pulse; | |
e40b1127 DH |
169 | data->state = STATE_TOGGLE_END; |
170 | return 0; | |
784a4931 DH |
171 | |
172 | case STATE_TOGGLE_END: | |
d8b4b582 | 173 | if (!is_transition(&ev, &dev->raw->prev_ev) || |
e40b1127 DH |
174 | !geq_margin(ev.duration, RC6_TOGGLE_END, RC6_UNIT / 2)) |
175 | break; | |
784a4931 | 176 | |
e40b1127 DH |
177 | if (!(data->header & RC6_STARTBIT_MASK)) { |
178 | IR_dprintk(1, "RC6 invalid start bit\n"); | |
179 | break; | |
180 | } | |
784a4931 | 181 | |
e40b1127 | 182 | data->state = STATE_BODY_BIT_START; |
e40b1127 DH |
183 | decrease_duration(&ev, RC6_TOGGLE_END); |
184 | data->count = 0; | |
db9bc660 | 185 | data->body = 0; |
e40b1127 DH |
186 | |
187 | switch (rc6_mode(data)) { | |
188 | case RC6_MODE_0: | |
189 | data->wanted_bits = RC6_0_NBITS; | |
190 | break; | |
191 | case RC6_MODE_6A: | |
db9bc660 | 192 | data->wanted_bits = RC6_6A_NBITS; |
e40b1127 DH |
193 | break; |
194 | default: | |
195 | IR_dprintk(1, "RC6 unknown mode\n"); | |
196 | goto out; | |
784a4931 | 197 | } |
e40b1127 | 198 | goto again; |
784a4931 DH |
199 | |
200 | case STATE_BODY_BIT_START: | |
db9bc660 | 201 | if (eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2)) { |
202 | /* Discard LSB's that won't fit in data->body */ | |
203 | if (data->count++ < CHAR_BIT * sizeof data->body) { | |
204 | data->body <<= 1; | |
205 | if (ev.pulse) | |
206 | data->body |= 1; | |
207 | } | |
208 | data->state = STATE_BODY_BIT_END; | |
209 | return 0; | |
210 | } else if (RC6_MODE_6A == rc6_mode(data) && !ev.pulse && | |
211 | geq_margin(ev.duration, RC6_SUFFIX_SPACE, RC6_UNIT / 2)) { | |
212 | data->state = STATE_FINISHED; | |
213 | goto again; | |
214 | } | |
215 | break; | |
784a4931 DH |
216 | |
217 | case STATE_BODY_BIT_END: | |
d8b4b582 | 218 | if (!is_transition(&ev, &dev->raw->prev_ev)) |
e40b1127 | 219 | break; |
784a4931 | 220 | |
e40b1127 DH |
221 | if (data->count == data->wanted_bits) |
222 | data->state = STATE_FINISHED; | |
223 | else | |
224 | data->state = STATE_BODY_BIT_START; | |
225 | ||
226 | decrease_duration(&ev, RC6_BIT_END); | |
227 | goto again; | |
784a4931 DH |
228 | |
229 | case STATE_FINISHED: | |
e40b1127 DH |
230 | if (ev.pulse) |
231 | break; | |
232 | ||
784a4931 DH |
233 | switch (rc6_mode(data)) { |
234 | case RC6_MODE_0: | |
db9bc660 | 235 | scancode = data->body; |
784a4931 | 236 | toggle = data->toggle; |
120703f9 | 237 | protocol = RC_TYPE_RC6_0; |
784a4931 DH |
238 | IR_dprintk(1, "RC6(0) scancode 0x%04x (toggle: %u)\n", |
239 | scancode, toggle); | |
240 | break; | |
120703f9 | 241 | |
784a4931 | 242 | case RC6_MODE_6A: |
db9bc660 | 243 | if (data->count > CHAR_BIT * sizeof data->body) { |
244 | IR_dprintk(1, "RC6 too many (%u) data bits\n", | |
245 | data->count); | |
246 | goto out; | |
247 | } | |
248 | ||
249 | scancode = data->body; | |
120703f9 DH |
250 | switch (data->count) { |
251 | case 20: | |
252 | protocol = RC_TYPE_RC6_6A_20; | |
253 | toggle = 0; | |
254 | break; | |
255 | case 24: | |
256 | protocol = RC_BIT_RC6_6A_24; | |
784a4931 | 257 | toggle = 0; |
120703f9 DH |
258 | break; |
259 | case 32: | |
260 | if ((scancode & RC6_6A_LCC_MASK) == RC6_6A_MCE_CC) { | |
261 | protocol = RC_TYPE_RC6_MCE; | |
120703f9 | 262 | toggle = !!(scancode & RC6_6A_MCE_TOGGLE_MASK); |
d2a74581 | 263 | scancode &= ~RC6_6A_MCE_TOGGLE_MASK; |
120703f9 DH |
264 | } else { |
265 | protocol = RC_BIT_RC6_6A_32; | |
266 | toggle = 0; | |
267 | } | |
268 | break; | |
269 | default: | |
270 | IR_dprintk(1, "RC6(6A) unsupported length\n"); | |
271 | goto out; | |
784a4931 | 272 | } |
120703f9 DH |
273 | |
274 | IR_dprintk(1, "RC6(6A) proto 0x%04x, scancode 0x%08x (toggle: %u)\n", | |
275 | protocol, scancode, toggle); | |
784a4931 DH |
276 | break; |
277 | default: | |
278 | IR_dprintk(1, "RC6 unknown mode\n"); | |
279 | goto out; | |
280 | } | |
281 | ||
120703f9 | 282 | rc_keydown(dev, protocol, scancode, toggle); |
784a4931 DH |
283 | data->state = STATE_INACTIVE; |
284 | return 0; | |
285 | } | |
286 | ||
287 | out: | |
e40b1127 DH |
288 | IR_dprintk(1, "RC6 decode failed at state %i (%uus %s)\n", |
289 | data->state, TO_US(ev.duration), TO_STR(ev.pulse)); | |
784a4931 DH |
290 | data->state = STATE_INACTIVE; |
291 | return -EINVAL; | |
292 | } | |
293 | ||
784a4931 | 294 | static struct ir_raw_handler rc6_handler = { |
c003ab1b DH |
295 | .protocols = RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 | |
296 | RC_BIT_RC6_6A_24 | RC_BIT_RC6_6A_32 | | |
297 | RC_BIT_RC6_MCE, | |
784a4931 | 298 | .decode = ir_rc6_decode, |
784a4931 DH |
299 | }; |
300 | ||
301 | static int __init ir_rc6_decode_init(void) | |
302 | { | |
303 | ir_raw_handler_register(&rc6_handler); | |
304 | ||
305 | printk(KERN_INFO "IR RC6 protocol handler initialized\n"); | |
306 | return 0; | |
307 | } | |
308 | ||
309 | static void __exit ir_rc6_decode_exit(void) | |
310 | { | |
311 | ir_raw_handler_unregister(&rc6_handler); | |
312 | } | |
313 | ||
314 | module_init(ir_rc6_decode_init); | |
315 | module_exit(ir_rc6_decode_exit); | |
316 | ||
317 | MODULE_LICENSE("GPL"); | |
318 | MODULE_AUTHOR("David Härdeman <david@hardeman.nu>"); | |
319 | MODULE_DESCRIPTION("RC6 IR protocol decoder"); |