1 /* ir-nec-decoder.c - handle NEC IR Pulse/Space protocol
3 * Copyright (C) 2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
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.
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.
15 #include <media/ir-core.h>
18 #define NEC_UNIT 559979 /* ns */
19 #define NEC_HEADER_MARK (16 * NEC_UNIT)
20 #define NEC_HEADER_SPACE (8 * NEC_UNIT)
21 #define NEC_REPEAT_SPACE (4 * NEC_UNIT)
22 #define NEC_MARK (NEC_UNIT)
23 #define NEC_0_SPACE (NEC_UNIT)
24 #define NEC_1_SPACE (3 * NEC_UNIT)
26 /* Used to register nec_decoder clients */
27 static LIST_HEAD(decoder_list);
28 static spinlock_t decoder_lock;
48 struct list_head list;
49 struct ir_input_dev *ir_dev;
52 /* State machine control */
54 struct nec_code nec_code;
60 * get_decoder_data() - gets decoder data
61 * @input_dev: input device
63 * Returns the struct decoder_data that corresponds to a device
66 static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
68 struct decoder_data *data = NULL;
70 spin_lock(&decoder_lock);
71 list_for_each_entry(data, &decoder_list, list) {
72 if (data->ir_dev == ir_dev)
75 spin_unlock(&decoder_lock);
79 static ssize_t store_enabled(struct device *d,
80 struct device_attribute *mattr,
85 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
86 struct decoder_data *data = get_decoder_data(ir_dev);
91 if (strict_strtoul(buf, 10, &value) || value > 1)
94 data->enabled = value;
99 static ssize_t show_enabled(struct device *d,
100 struct device_attribute *mattr, char *buf)
102 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
103 struct decoder_data *data = get_decoder_data(ir_dev);
109 return sprintf(buf, "1\n");
111 return sprintf(buf, "0\n");
114 static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
116 static struct attribute *decoder_attributes[] = {
117 &dev_attr_enabled.attr,
121 static struct attribute_group decoder_attribute_group = {
122 .name = "nec_decoder",
123 .attrs = decoder_attributes,
128 * ir_nec_decode() - Decode one NEC pulse or space
129 * @input_dev: the struct input_dev descriptor of the device
130 * @ev: event array with type/duration of pulse/space
132 * This function returns -EINVAL if the pulse violates the state machine
134 static int ir_nec_decode(struct input_dev *input_dev,
135 struct ir_raw_event *ev)
137 struct decoder_data *data;
138 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
141 data = get_decoder_data(ir_dev);
148 /* Except for the initial event, what matters is the previous bit */
149 bit = (ev->type & IR_PULSE) ? 1 : 0;
153 /* Discards spurious space last_bits when inactive */
155 /* Very long delays are considered as start events */
156 if (ev->delta.tv_nsec > NEC_HEADER_MARK + NEC_HEADER_SPACE - NEC_UNIT / 2)
157 data->state = STATE_INACTIVE;
159 if (ev->type & IR_START_EVENT)
160 data->state = STATE_INACTIVE;
162 switch (data->state) {
164 if (!bit) /* PULSE marks the start event */
168 data->state = STATE_HEADER_MARK;
169 memset (&data->nec_code, 0, sizeof(data->nec_code));
171 case STATE_HEADER_MARK:
174 if (ev->delta.tv_nsec < NEC_HEADER_MARK - 6 * NEC_UNIT)
176 data->state = STATE_HEADER_SPACE;
178 case STATE_HEADER_SPACE:
181 if (ev->delta.tv_nsec >= NEC_HEADER_SPACE - NEC_UNIT / 2) {
182 data->state = STATE_MARK;
186 if (ev->delta.tv_nsec >= NEC_REPEAT_SPACE - NEC_UNIT / 2) {
187 ir_repeat(input_dev);
188 IR_dprintk(1, "Repeat last key\n");
189 data->state = STATE_TRAILER_MARK;
196 if ((ev->delta.tv_nsec > NEC_MARK + NEC_UNIT / 2) ||
197 (ev->delta.tv_nsec < NEC_MARK - NEC_UNIT / 2))
199 data->state = STATE_SPACE;
205 if ((ev->delta.tv_nsec >= NEC_0_SPACE - NEC_UNIT / 2) &&
206 (ev->delta.tv_nsec < NEC_0_SPACE + NEC_UNIT / 2))
208 else if ((ev->delta.tv_nsec >= NEC_1_SPACE - NEC_UNIT / 2) &&
209 (ev->delta.tv_nsec < NEC_1_SPACE + NEC_UNIT / 2))
212 IR_dprintk(1, "Decode failed at %d-th bit (%s) @%luus\n",
214 last_bit ? "pulse" : "space",
215 (ev->delta.tv_nsec + 500) / 1000);
220 /* Ok, we've got a valid bit. proccess it */
222 int shift = data->count;
225 * NEC transmit bytes on this temporal order:
226 * address | not address | command | not command
229 data->nec_code.address |= 1 << shift;
230 } else if (shift < 16) {
231 data->nec_code.not_address |= 1 << (shift - 8);
232 } else if (shift < 24) {
233 data->nec_code.command |= 1 << (shift - 16);
235 data->nec_code.not_command |= 1 << (shift - 24);
238 if (++data->count == NEC_NBITS) {
241 * Fixme: may need to accept Extended NEC protocol?
243 if ((data->nec_code.command ^ data->nec_code.not_command) != 0xff)
246 if ((data->nec_code.address ^ data->nec_code.not_address) != 0xff) {
248 scancode = data->nec_code.address << 16 |
249 data->nec_code.not_address << 8 |
250 data->nec_code.command;
251 IR_dprintk(1, "NEC scancode 0x%06x\n", scancode);
254 scancode = data->nec_code.address << 8 |
255 data->nec_code.command;
256 IR_dprintk(1, "NEC scancode 0x%04x\n", scancode);
258 ir_keydown(input_dev, scancode, 0);
260 data->state = STATE_TRAILER_MARK;
262 data->state = STATE_MARK;
264 case STATE_TRAILER_MARK:
267 data->state = STATE_TRAILER_SPACE;
269 case STATE_TRAILER_SPACE:
272 data->state = STATE_INACTIVE;
277 IR_dprintk(1, "NEC decoded failed at state %d (%s) @ %luus\n",
279 bit ? "pulse" : "space",
280 (ev->delta.tv_nsec + 500) / 1000);
282 data->state = STATE_INACTIVE;
286 data->state = STATE_INACTIVE;
287 IR_dprintk(1, "NEC checksum error: received 0x%02x%02x%02x%02x\n",
288 data->nec_code.address,
289 data->nec_code.not_address,
290 data->nec_code.command,
291 data->nec_code.not_command);
295 static int ir_nec_register(struct input_dev *input_dev)
297 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
298 struct decoder_data *data;
301 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
305 data = kzalloc(sizeof(*data), GFP_KERNEL);
307 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
311 data->ir_dev = ir_dev;
314 spin_lock(&decoder_lock);
315 list_add_tail(&data->list, &decoder_list);
316 spin_unlock(&decoder_lock);
321 static int ir_nec_unregister(struct input_dev *input_dev)
323 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
324 static struct decoder_data *data;
326 data = get_decoder_data(ir_dev);
330 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
332 spin_lock(&decoder_lock);
333 list_del(&data->list);
334 spin_unlock(&decoder_lock);
339 static struct ir_raw_handler nec_handler = {
340 .decode = ir_nec_decode,
341 .raw_register = ir_nec_register,
342 .raw_unregister = ir_nec_unregister,
345 static int __init ir_nec_decode_init(void)
347 ir_raw_handler_register(&nec_handler);
349 printk(KERN_INFO "IR NEC protocol handler initialized\n");
353 static void __exit ir_nec_decode_exit(void)
355 ir_raw_handler_unregister(&nec_handler);
358 module_init(ir_nec_decode_init);
359 module_exit(ir_nec_decode_exit);
361 MODULE_LICENSE("GPL");
362 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
363 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
364 MODULE_DESCRIPTION("NEC IR protocol decoder");