1 /* ir-rc5-decoder.c - handle RC-5 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 only handles 14 bits RC-5 protocols. There are other variants
17 * that use a different number of bits. This is currently unsupported
18 * It considers a carrier of 36 kHz, with a total of 14 bits, where
19 * the first two bits are start bits, and a third one is a filing bit
22 #include <media/ir-core.h>
25 #define RC5_UNIT 888888 /* ns */
27 /* Used to register rc5_decoder clients */
28 static LIST_HEAD(decoder_list);
29 static DEFINE_SPINLOCK(decoder_lock);
39 struct list_head list;
40 struct ir_input_dev *ir_dev;
43 /* State machine control */
52 * get_decoder_data() - gets decoder data
53 * @input_dev: input device
55 * 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 = "rc5_decoder",
115 .attrs = decoder_attributes,
119 * ir_rc5_decode() - Decode one RC-5 pulse or space
120 * @input_dev: the struct input_dev descriptor of the device
121 * @duration: duration of pulse/space in ns
123 * This function returns -EINVAL if the pulse violates the state machine
125 static int ir_rc5_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);
129 u8 command, system, toggle;
133 data = get_decoder_data(ir_dev);
140 if (IS_RESET(duration)) {
141 data->state = STATE_INACTIVE;
145 u = TO_UNITS(duration, RC5_UNIT);
146 if (DURATION(u) == 0)
150 IR_dprintk(2, "RC5 decode started at state %i (%i units, %ius)\n",
151 data->state, u, TO_US(duration));
153 if (DURATION(u) == 0 && data->state != STATE_FINISHED)
156 switch (data->state) {
160 data->state = STATE_BIT_START;
162 DECREASE_DURATION(u, 1);
167 case STATE_BIT_START:
168 if (DURATION(u) == 1) {
169 data->rc5_bits <<= 1;
176 * If the last bit is zero, a space will merge
177 * with the silence after the command.
179 if (IS_PULSE(u) && data->count == RC5_NBITS) {
180 data->state = STATE_FINISHED;
184 data->state = STATE_BIT_END;
190 if (IS_TRANSITION(u, data->last_unit)) {
191 if (data->count == RC5_NBITS)
192 data->state = STATE_FINISHED;
194 data->state = STATE_BIT_START;
196 DECREASE_DURATION(u, 1);
202 command = (data->rc5_bits & 0x0003F) >> 0;
203 system = (data->rc5_bits & 0x007C0) >> 6;
204 toggle = (data->rc5_bits & 0x00800) ? 1 : 0;
205 command += (data->rc5_bits & 0x01000) ? 0 : 0x40;
206 scancode = system << 8 | command;
208 IR_dprintk(1, "RC5 scancode 0x%04x (toggle: %u)\n",
210 ir_keydown(input_dev, scancode, toggle);
211 data->state = STATE_INACTIVE;
216 IR_dprintk(1, "RC5 decode failed at state %i (%i units, %ius)\n",
217 data->state, u, TO_US(duration));
218 data->state = STATE_INACTIVE;
222 static int ir_rc5_register(struct input_dev *input_dev)
224 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
225 struct decoder_data *data;
228 rc = sysfs_create_group(&ir_dev->dev.kobj, &decoder_attribute_group);
232 data = kzalloc(sizeof(*data), GFP_KERNEL);
234 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
238 data->ir_dev = ir_dev;
241 spin_lock(&decoder_lock);
242 list_add_tail(&data->list, &decoder_list);
243 spin_unlock(&decoder_lock);
248 static int ir_rc5_unregister(struct input_dev *input_dev)
250 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
251 static struct decoder_data *data;
253 data = get_decoder_data(ir_dev);
257 sysfs_remove_group(&ir_dev->dev.kobj, &decoder_attribute_group);
259 spin_lock(&decoder_lock);
260 list_del(&data->list);
261 spin_unlock(&decoder_lock);
266 static struct ir_raw_handler rc5_handler = {
267 .decode = ir_rc5_decode,
268 .raw_register = ir_rc5_register,
269 .raw_unregister = ir_rc5_unregister,
272 static int __init ir_rc5_decode_init(void)
274 ir_raw_handler_register(&rc5_handler);
276 printk(KERN_INFO "IR RC-5 protocol handler initialized\n");
280 static void __exit ir_rc5_decode_exit(void)
282 ir_raw_handler_unregister(&rc5_handler);
285 module_init(ir_rc5_decode_init);
286 module_exit(ir_rc5_decode_exit);
288 MODULE_LICENSE("GPL");
289 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
290 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
291 MODULE_DESCRIPTION("RC-5 IR protocol decoder");