1 /* ir-rc5-decoder.c - handle RC5(x) 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.
16 * This code handles 14 bits RC5 protocols and 20 bits RC5x protocols.
17 * There are other variants that use a different number of bits.
18 * This is currently unsupported.
19 * It considers a carrier of 36 kHz, with a total of 14/20 bits, where
20 * the first two bits are start bits, and a third one is a filing bit
23 #include "ir-core-priv.h"
27 #define CHECK_RC5X_NBITS 8
28 #define RC5_UNIT 888888 /* ns */
29 #define RC5_BIT_START (1 * RC5_UNIT)
30 #define RC5_BIT_END (1 * RC5_UNIT)
31 #define RC5X_SPACE (4 * RC5_UNIT)
33 /* Used to register rc5_decoder clients */
34 static LIST_HEAD(decoder_list);
35 static DEFINE_SPINLOCK(decoder_lock);
46 struct list_head list;
47 struct ir_input_dev *ir_dev;
50 /* State machine control */
53 struct ir_raw_event prev_ev;
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 = "rc5_decoder",
123 .attrs = decoder_attributes,
127 * ir_rc5_decode() - Decode one RC-5 pulse or space
128 * @input_dev: the struct input_dev descriptor of the device
129 * @ev: the struct ir_raw_event descriptor of the pulse/space
131 * This function returns -EINVAL if the pulse violates the state machine
133 static int ir_rc5_decode(struct input_dev *input_dev, struct ir_raw_event ev)
135 struct decoder_data *data;
136 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
140 data = get_decoder_data(ir_dev);
148 data->state = STATE_INACTIVE;
152 if (!geq_margin(ev.duration, RC5_UNIT, RC5_UNIT / 2))
156 IR_dprintk(2, "RC5(x) decode started at state %i (%uus %s)\n",
157 data->state, TO_US(ev.duration), TO_STR(ev.pulse));
159 if (!geq_margin(ev.duration, RC5_UNIT, RC5_UNIT / 2))
162 switch (data->state) {
168 data->state = STATE_BIT_START;
170 /* We just need enough bits to get to STATE_CHECK_RC5X */
171 data->wanted_bits = RC5X_NBITS;
172 decrease_duration(&ev, RC5_BIT_START);
175 case STATE_BIT_START:
176 if (!eq_margin(ev.duration, RC5_BIT_START, RC5_UNIT / 2))
179 data->rc5_bits <<= 1;
184 data->state = STATE_BIT_END;
188 if (!is_transition(&ev, &data->prev_ev))
191 if (data->count == data->wanted_bits)
192 data->state = STATE_FINISHED;
193 else if (data->count == CHECK_RC5X_NBITS)
194 data->state = STATE_CHECK_RC5X;
196 data->state = STATE_BIT_START;
198 decrease_duration(&ev, RC5_BIT_END);
201 case STATE_CHECK_RC5X:
202 if (!ev.pulse && geq_margin(ev.duration, RC5X_SPACE, RC5_UNIT / 2)) {
204 data->wanted_bits = RC5X_NBITS;
205 decrease_duration(&ev, RC5X_SPACE);
208 data->wanted_bits = RC5_NBITS;
210 data->state = STATE_BIT_START;
217 if (data->wanted_bits == RC5X_NBITS) {
219 u8 xdata, command, system;
220 xdata = (data->rc5_bits & 0x0003F) >> 0;
221 command = (data->rc5_bits & 0x00FC0) >> 6;
222 system = (data->rc5_bits & 0x1F000) >> 12;
223 toggle = (data->rc5_bits & 0x20000) ? 1 : 0;
224 command += (data->rc5_bits & 0x01000) ? 0 : 0x40;
225 scancode = system << 16 | command << 8 | xdata;
227 IR_dprintk(1, "RC5X scancode 0x%06x (toggle: %u)\n",
233 command = (data->rc5_bits & 0x0003F) >> 0;
234 system = (data->rc5_bits & 0x007C0) >> 6;
235 toggle = (data->rc5_bits & 0x00800) ? 1 : 0;
236 command += (data->rc5_bits & 0x01000) ? 0 : 0x40;
237 scancode = system << 8 | command;
239 IR_dprintk(1, "RC5 scancode 0x%04x (toggle: %u)\n",
243 ir_keydown(input_dev, scancode, toggle);
244 data->state = STATE_INACTIVE;
249 IR_dprintk(1, "RC5(x) decode failed at state %i (%uus %s)\n",
250 data->state, TO_US(ev.duration), TO_STR(ev.pulse));
251 data->state = STATE_INACTIVE;
255 static int ir_rc5_register(struct input_dev *input_dev)
257 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
258 struct decoder_data *data;
261 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
265 data = kzalloc(sizeof(*data), GFP_KERNEL);
267 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
271 data->ir_dev = ir_dev;
274 spin_lock(&decoder_lock);
275 list_add_tail(&data->list, &decoder_list);
276 spin_unlock(&decoder_lock);
281 static int ir_rc5_unregister(struct input_dev *input_dev)
283 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
284 static struct decoder_data *data;
286 data = get_decoder_data(ir_dev);
290 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
292 spin_lock(&decoder_lock);
293 list_del(&data->list);
294 spin_unlock(&decoder_lock);
299 static struct ir_raw_handler rc5_handler = {
300 .decode = ir_rc5_decode,
301 .raw_register = ir_rc5_register,
302 .raw_unregister = ir_rc5_unregister,
305 static int __init ir_rc5_decode_init(void)
307 ir_raw_handler_register(&rc5_handler);
309 printk(KERN_INFO "IR RC5(x) protocol handler initialized\n");
313 static void __exit ir_rc5_decode_exit(void)
315 ir_raw_handler_unregister(&rc5_handler);
318 module_init(ir_rc5_decode_init);
319 module_exit(ir_rc5_decode_exit);
321 MODULE_LICENSE("GPL");
322 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
323 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
324 MODULE_DESCRIPTION("RC5(x) IR protocol decoder");