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>
16 #include <linux/bitrev.h>
19 #define NEC_UNIT 562500 /* ns */
20 #define NEC_HEADER_PULSE PULSE(16)
21 #define NEC_HEADER_SPACE SPACE(8)
22 #define NEC_REPEAT_SPACE SPACE(4)
23 #define NEC_BIT_PULSE PULSE(1)
24 #define NEC_BIT_0_SPACE SPACE(1)
25 #define NEC_BIT_1_SPACE SPACE(3)
27 /* Used to register nec_decoder clients */
28 static LIST_HEAD(decoder_list);
29 static DEFINE_SPINLOCK(decoder_lock);
41 struct list_head list;
42 struct ir_input_dev *ir_dev;
45 /* State machine control */
53 * get_decoder_data() - gets decoder data
54 * @input_dev: input device
56 * Returns the struct decoder_data that corresponds to a device
58 static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
60 struct decoder_data *data = NULL;
62 spin_lock(&decoder_lock);
63 list_for_each_entry(data, &decoder_list, list) {
64 if (data->ir_dev == ir_dev)
67 spin_unlock(&decoder_lock);
71 static ssize_t store_enabled(struct device *d,
72 struct device_attribute *mattr,
77 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
78 struct decoder_data *data = get_decoder_data(ir_dev);
83 if (strict_strtoul(buf, 10, &value) || value > 1)
86 data->enabled = value;
91 static ssize_t show_enabled(struct device *d,
92 struct device_attribute *mattr, char *buf)
94 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
95 struct decoder_data *data = get_decoder_data(ir_dev);
101 return sprintf(buf, "1\n");
103 return sprintf(buf, "0\n");
106 static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
108 static struct attribute *decoder_attributes[] = {
109 &dev_attr_enabled.attr,
113 static struct attribute_group decoder_attribute_group = {
114 .name = "nec_decoder",
115 .attrs = decoder_attributes,
119 * ir_nec_decode() - Decode one NEC pulse or space
120 * @input_dev: the struct input_dev descriptor of the device
121 * @duration: duration in ns of pulse/space
123 * This function returns -EINVAL if the pulse violates the state machine
125 static int ir_nec_decode(struct input_dev *input_dev, s64 duration)
127 struct decoder_data *data;
128 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
131 u8 address, not_address, command, not_command;
133 data = get_decoder_data(ir_dev);
140 if (IS_RESET(duration)) {
141 data->state = STATE_INACTIVE;
145 u = TO_UNITS(duration, NEC_UNIT);
146 if (DURATION(u) == 0)
149 IR_dprintk(2, "NEC decode started at state %d (%i units, %ius)\n",
150 data->state, u, TO_US(duration));
152 switch (data->state) {
155 if (u == NEC_HEADER_PULSE) {
157 data->state = STATE_HEADER_SPACE;
161 case STATE_HEADER_SPACE:
162 if (u == NEC_HEADER_SPACE) {
163 data->state = STATE_BIT_PULSE;
165 } else if (u == NEC_REPEAT_SPACE) {
166 ir_repeat(input_dev);
167 IR_dprintk(1, "Repeat last key\n");
168 data->state = STATE_TRAILER_PULSE;
173 case STATE_BIT_PULSE:
174 if (u == NEC_BIT_PULSE) {
175 data->state = STATE_BIT_SPACE;
180 case STATE_BIT_SPACE:
181 if (u != NEC_BIT_0_SPACE && u != NEC_BIT_1_SPACE)
184 data->nec_bits <<= 1;
185 if (u == NEC_BIT_1_SPACE)
189 if (data->count != NEC_NBITS) {
190 data->state = STATE_BIT_PULSE;
194 address = bitrev8((data->nec_bits >> 24) & 0xff);
195 not_address = bitrev8((data->nec_bits >> 16) & 0xff);
196 command = bitrev8((data->nec_bits >> 8) & 0xff);
197 not_command = bitrev8((data->nec_bits >> 0) & 0xff);
199 if ((command ^ not_command) != 0xff) {
200 IR_dprintk(1, "NEC checksum error: received 0x%08x\n",
205 if ((address ^ not_address) != 0xff) {
207 scancode = address << 16 |
210 IR_dprintk(1, "NEC (Ext) scancode 0x%06x\n", scancode);
213 scancode = address << 8 | command;
214 IR_dprintk(1, "NEC scancode 0x%04x\n", scancode);
217 ir_keydown(input_dev, scancode, 0);
218 data->state = STATE_TRAILER_PULSE;
221 case STATE_TRAILER_PULSE:
223 data->state = STATE_TRAILER_SPACE;
228 case STATE_TRAILER_SPACE:
230 data->state = STATE_INACTIVE;
238 IR_dprintk(1, "NEC decode failed at state %d (%i units, %ius)\n",
239 data->state, u, TO_US(duration));
240 data->state = STATE_INACTIVE;
244 static int ir_nec_register(struct input_dev *input_dev)
246 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
247 struct decoder_data *data;
250 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
254 data = kzalloc(sizeof(*data), GFP_KERNEL);
256 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
260 data->ir_dev = ir_dev;
263 spin_lock(&decoder_lock);
264 list_add_tail(&data->list, &decoder_list);
265 spin_unlock(&decoder_lock);
270 static int ir_nec_unregister(struct input_dev *input_dev)
272 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
273 static struct decoder_data *data;
275 data = get_decoder_data(ir_dev);
279 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
281 spin_lock(&decoder_lock);
282 list_del(&data->list);
283 spin_unlock(&decoder_lock);
288 static struct ir_raw_handler nec_handler = {
289 .decode = ir_nec_decode,
290 .raw_register = ir_nec_register,
291 .raw_unregister = ir_nec_unregister,
294 static int __init ir_nec_decode_init(void)
296 ir_raw_handler_register(&nec_handler);
298 printk(KERN_INFO "IR NEC protocol handler initialized\n");
302 static void __exit ir_nec_decode_exit(void)
304 ir_raw_handler_unregister(&nec_handler);
307 module_init(ir_nec_decode_init);
308 module_exit(ir_nec_decode_exit);
310 MODULE_LICENSE("GPL");
311 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
312 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
313 MODULE_DESCRIPTION("NEC IR protocol decoder");