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; | |
784a4931 | 91 | |
c003ab1b DH |
92 | if (!(dev->raw->enabled_protocols & |
93 | (RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 | RC_BIT_RC6_6A_24 | | |
94 | RC_BIT_RC6_6A_32 | RC_BIT_RC6_MCE))) | |
784a4931 DH |
95 | return 0; |
96 | ||
4651918a ML |
97 | if (!is_timing_event(ev)) { |
98 | if (ev.reset) | |
99 | data->state = STATE_INACTIVE; | |
784a4931 DH |
100 | return 0; |
101 | } | |
102 | ||
e40b1127 | 103 | if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2)) |
784a4931 DH |
104 | goto out; |
105 | ||
106 | again: | |
e40b1127 DH |
107 | IR_dprintk(2, "RC6 decode started at state %i (%uus %s)\n", |
108 | data->state, TO_US(ev.duration), TO_STR(ev.pulse)); | |
784a4931 | 109 | |
e40b1127 | 110 | if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2)) |
784a4931 DH |
111 | return 0; |
112 | ||
113 | switch (data->state) { | |
114 | ||
115 | case STATE_INACTIVE: | |
e40b1127 DH |
116 | if (!ev.pulse) |
117 | break; | |
118 | ||
119 | /* Note: larger margin on first pulse since each RC6_UNIT | |
120 | is quite short and some hardware takes some time to | |
121 | adjust to the signal */ | |
122 | if (!eq_margin(ev.duration, RC6_PREFIX_PULSE, RC6_UNIT)) | |
123 | break; | |
124 | ||
125 | data->state = STATE_PREFIX_SPACE; | |
126 | data->count = 0; | |
127 | return 0; | |
784a4931 DH |
128 | |
129 | case STATE_PREFIX_SPACE: | |
e40b1127 DH |
130 | if (ev.pulse) |
131 | break; | |
132 | ||
133 | if (!eq_margin(ev.duration, RC6_PREFIX_SPACE, RC6_UNIT / 2)) | |
134 | break; | |
135 | ||
136 | data->state = STATE_HEADER_BIT_START; | |
db9bc660 | 137 | data->header = 0; |
e40b1127 | 138 | return 0; |
784a4931 DH |
139 | |
140 | case STATE_HEADER_BIT_START: | |
e40b1127 DH |
141 | if (!eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2)) |
142 | break; | |
143 | ||
144 | data->header <<= 1; | |
145 | if (ev.pulse) | |
146 | data->header |= 1; | |
147 | data->count++; | |
e40b1127 DH |
148 | data->state = STATE_HEADER_BIT_END; |
149 | return 0; | |
784a4931 DH |
150 | |
151 | case STATE_HEADER_BIT_END: | |
d8b4b582 | 152 | if (!is_transition(&ev, &dev->raw->prev_ev)) |
e40b1127 | 153 | break; |
784a4931 | 154 | |
e40b1127 DH |
155 | if (data->count == RC6_HEADER_NBITS) |
156 | data->state = STATE_TOGGLE_START; | |
157 | else | |
158 | data->state = STATE_HEADER_BIT_START; | |
159 | ||
160 | decrease_duration(&ev, RC6_BIT_END); | |
161 | goto again; | |
784a4931 DH |
162 | |
163 | case STATE_TOGGLE_START: | |
e40b1127 DH |
164 | if (!eq_margin(ev.duration, RC6_TOGGLE_START, RC6_UNIT / 2)) |
165 | break; | |
166 | ||
167 | data->toggle = ev.pulse; | |
e40b1127 DH |
168 | data->state = STATE_TOGGLE_END; |
169 | return 0; | |
784a4931 DH |
170 | |
171 | case STATE_TOGGLE_END: | |
d8b4b582 | 172 | if (!is_transition(&ev, &dev->raw->prev_ev) || |
e40b1127 DH |
173 | !geq_margin(ev.duration, RC6_TOGGLE_END, RC6_UNIT / 2)) |
174 | break; | |
784a4931 | 175 | |
e40b1127 DH |
176 | if (!(data->header & RC6_STARTBIT_MASK)) { |
177 | IR_dprintk(1, "RC6 invalid start bit\n"); | |
178 | break; | |
179 | } | |
784a4931 | 180 | |
e40b1127 | 181 | data->state = STATE_BODY_BIT_START; |
e40b1127 DH |
182 | decrease_duration(&ev, RC6_TOGGLE_END); |
183 | data->count = 0; | |
db9bc660 | 184 | data->body = 0; |
e40b1127 DH |
185 | |
186 | switch (rc6_mode(data)) { | |
187 | case RC6_MODE_0: | |
188 | data->wanted_bits = RC6_0_NBITS; | |
189 | break; | |
190 | case RC6_MODE_6A: | |
db9bc660 | 191 | data->wanted_bits = RC6_6A_NBITS; |
e40b1127 DH |
192 | break; |
193 | default: | |
194 | IR_dprintk(1, "RC6 unknown mode\n"); | |
195 | goto out; | |
784a4931 | 196 | } |
e40b1127 | 197 | goto again; |
784a4931 DH |
198 | |
199 | case STATE_BODY_BIT_START: | |
db9bc660 | 200 | if (eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2)) { |
201 | /* Discard LSB's that won't fit in data->body */ | |
202 | if (data->count++ < CHAR_BIT * sizeof data->body) { | |
203 | data->body <<= 1; | |
204 | if (ev.pulse) | |
205 | data->body |= 1; | |
206 | } | |
207 | data->state = STATE_BODY_BIT_END; | |
208 | return 0; | |
209 | } else if (RC6_MODE_6A == rc6_mode(data) && !ev.pulse && | |
210 | geq_margin(ev.duration, RC6_SUFFIX_SPACE, RC6_UNIT / 2)) { | |
211 | data->state = STATE_FINISHED; | |
212 | goto again; | |
213 | } | |
214 | break; | |
784a4931 DH |
215 | |
216 | case STATE_BODY_BIT_END: | |
d8b4b582 | 217 | if (!is_transition(&ev, &dev->raw->prev_ev)) |
e40b1127 | 218 | break; |
784a4931 | 219 | |
e40b1127 DH |
220 | if (data->count == data->wanted_bits) |
221 | data->state = STATE_FINISHED; | |
222 | else | |
223 | data->state = STATE_BODY_BIT_START; | |
224 | ||
225 | decrease_duration(&ev, RC6_BIT_END); | |
226 | goto again; | |
784a4931 DH |
227 | |
228 | case STATE_FINISHED: | |
e40b1127 DH |
229 | if (ev.pulse) |
230 | break; | |
231 | ||
784a4931 DH |
232 | switch (rc6_mode(data)) { |
233 | case RC6_MODE_0: | |
db9bc660 | 234 | scancode = data->body; |
784a4931 DH |
235 | toggle = data->toggle; |
236 | IR_dprintk(1, "RC6(0) scancode 0x%04x (toggle: %u)\n", | |
237 | scancode, toggle); | |
238 | break; | |
239 | case RC6_MODE_6A: | |
db9bc660 | 240 | if (data->count > CHAR_BIT * sizeof data->body) { |
241 | IR_dprintk(1, "RC6 too many (%u) data bits\n", | |
242 | data->count); | |
243 | goto out; | |
244 | } | |
245 | ||
246 | scancode = data->body; | |
247 | if (data->count == RC6_6A_32_NBITS && | |
248 | (scancode & RC6_6A_LCC_MASK) == RC6_6A_MCE_CC) { | |
249 | /* MCE RC */ | |
250 | toggle = (scancode & RC6_6A_MCE_TOGGLE_MASK) ? 1 : 0; | |
251 | scancode &= ~RC6_6A_MCE_TOGGLE_MASK; | |
784a4931 DH |
252 | } else { |
253 | toggle = 0; | |
784a4931 | 254 | } |
784a4931 DH |
255 | IR_dprintk(1, "RC6(6A) scancode 0x%08x (toggle: %u)\n", |
256 | scancode, toggle); | |
257 | break; | |
258 | default: | |
259 | IR_dprintk(1, "RC6 unknown mode\n"); | |
260 | goto out; | |
261 | } | |
262 | ||
ca86674b | 263 | rc_keydown(dev, scancode, toggle); |
784a4931 DH |
264 | data->state = STATE_INACTIVE; |
265 | return 0; | |
266 | } | |
267 | ||
268 | out: | |
e40b1127 DH |
269 | IR_dprintk(1, "RC6 decode failed at state %i (%uus %s)\n", |
270 | data->state, TO_US(ev.duration), TO_STR(ev.pulse)); | |
784a4931 DH |
271 | data->state = STATE_INACTIVE; |
272 | return -EINVAL; | |
273 | } | |
274 | ||
784a4931 | 275 | static struct ir_raw_handler rc6_handler = { |
c003ab1b DH |
276 | .protocols = RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 | |
277 | RC_BIT_RC6_6A_24 | RC_BIT_RC6_6A_32 | | |
278 | RC_BIT_RC6_MCE, | |
784a4931 | 279 | .decode = ir_rc6_decode, |
784a4931 DH |
280 | }; |
281 | ||
282 | static int __init ir_rc6_decode_init(void) | |
283 | { | |
284 | ir_raw_handler_register(&rc6_handler); | |
285 | ||
286 | printk(KERN_INFO "IR RC6 protocol handler initialized\n"); | |
287 | return 0; | |
288 | } | |
289 | ||
290 | static void __exit ir_rc6_decode_exit(void) | |
291 | { | |
292 | ir_raw_handler_unregister(&rc6_handler); | |
293 | } | |
294 | ||
295 | module_init(ir_rc6_decode_init); | |
296 | module_exit(ir_rc6_decode_exit); | |
297 | ||
298 | MODULE_LICENSE("GPL"); | |
299 | MODULE_AUTHOR("David Härdeman <david@hardeman.nu>"); | |
300 | MODULE_DESCRIPTION("RC6 IR protocol decoder"); |