1 /* ir-sony-decoder.c - handle Sony IR Pulse/Space protocol
3 * Copyright (C) 2010 by David Härdeman <david@hardeman.nu>
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 <linux/bitrev.h>
16 #include "ir-core-priv.h"
18 #define SONY_UNIT 600000 /* ns */
19 #define SONY_HEADER_PULSE (4 * SONY_UNIT)
20 #define SONY_HEADER_SPACE (1 * SONY_UNIT)
21 #define SONY_BIT_0_PULSE (1 * SONY_UNIT)
22 #define SONY_BIT_1_PULSE (2 * SONY_UNIT)
23 #define SONY_BIT_SPACE (1 * SONY_UNIT)
24 #define SONY_TRAILER_SPACE (10 * SONY_UNIT) /* minimum */
26 /* Used to register sony_decoder clients */
27 static LIST_HEAD(decoder_list);
28 static DEFINE_SPINLOCK(decoder_lock);
39 struct list_head list;
40 struct ir_input_dev *ir_dev;
43 /* State machine control */
44 enum sony_state state;
51 * get_decoder_data() - gets decoder data
52 * @input_dev: input device
54 * Returns the struct decoder_data that corresponds to a device
56 static struct decoder_data *get_decoder_data(struct ir_input_dev *ir_dev)
58 struct decoder_data *data = NULL;
60 spin_lock(&decoder_lock);
61 list_for_each_entry(data, &decoder_list, list) {
62 if (data->ir_dev == ir_dev)
65 spin_unlock(&decoder_lock);
69 static ssize_t store_enabled(struct device *d,
70 struct device_attribute *mattr,
75 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
76 struct decoder_data *data = get_decoder_data(ir_dev);
81 if (strict_strtoul(buf, 10, &value) || value > 1)
84 data->enabled = value;
89 static ssize_t show_enabled(struct device *d,
90 struct device_attribute *mattr, char *buf)
92 struct ir_input_dev *ir_dev = dev_get_drvdata(d);
93 struct decoder_data *data = get_decoder_data(ir_dev);
99 return sprintf(buf, "1\n");
101 return sprintf(buf, "0\n");
104 static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, show_enabled, store_enabled);
106 static struct attribute *decoder_attributes[] = {
107 &dev_attr_enabled.attr,
111 static struct attribute_group decoder_attribute_group = {
112 .name = "sony_decoder",
113 .attrs = decoder_attributes,
117 * ir_sony_decode() - Decode one Sony pulse or space
118 * @input_dev: the struct input_dev descriptor of the device
119 * @ev: the struct ir_raw_event descriptor of the pulse/space
121 * This function returns -EINVAL if the pulse violates the state machine
123 static int ir_sony_decode(struct input_dev *input_dev, struct ir_raw_event ev)
125 struct decoder_data *data;
126 struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
128 u8 device, subdevice, function;
130 data = get_decoder_data(ir_dev);
138 data->state = STATE_INACTIVE;
142 if (!geq_margin(ev.duration, SONY_UNIT, SONY_UNIT / 2))
145 IR_dprintk(2, "Sony decode started at state %d (%uus %s)\n",
146 data->state, TO_US(ev.duration), TO_STR(ev.pulse));
148 switch (data->state) {
154 if (!eq_margin(ev.duration, SONY_HEADER_PULSE, SONY_UNIT / 2))
158 data->state = STATE_HEADER_SPACE;
161 case STATE_HEADER_SPACE:
165 if (!eq_margin(ev.duration, SONY_HEADER_SPACE, SONY_UNIT / 2))
168 data->state = STATE_BIT_PULSE;
171 case STATE_BIT_PULSE:
175 data->sony_bits <<= 1;
176 if (eq_margin(ev.duration, SONY_BIT_1_PULSE, SONY_UNIT / 2))
177 data->sony_bits |= 1;
178 else if (!eq_margin(ev.duration, SONY_BIT_0_PULSE, SONY_UNIT / 2))
182 data->state = STATE_BIT_SPACE;
185 case STATE_BIT_SPACE:
189 if (!geq_margin(ev.duration, SONY_BIT_SPACE, SONY_UNIT / 2))
192 decrease_duration(&ev, SONY_BIT_SPACE);
194 if (!geq_margin(ev.duration, SONY_UNIT, SONY_UNIT / 2)) {
195 data->state = STATE_BIT_PULSE;
199 data->state = STATE_FINISHED;
206 if (!geq_margin(ev.duration, SONY_TRAILER_SPACE, SONY_UNIT / 2))
209 switch (data->count) {
211 device = bitrev8((data->sony_bits << 3) & 0xF8);
213 function = bitrev8((data->sony_bits >> 4) & 0xFE);
216 device = bitrev8((data->sony_bits >> 0) & 0xFF);
218 function = bitrev8((data->sony_bits >> 7) & 0xFD);
221 device = bitrev8((data->sony_bits >> 5) & 0xF8);
222 subdevice = bitrev8((data->sony_bits >> 0) & 0xFF);
223 function = bitrev8((data->sony_bits >> 12) & 0xFE);
226 IR_dprintk(1, "Sony invalid bitcount %u\n", data->count);
230 scancode = device << 16 | subdevice << 8 | function;
231 IR_dprintk(1, "Sony(%u) scancode 0x%05x\n", data->count, scancode);
232 ir_keydown(input_dev, scancode, 0);
233 data->state = STATE_INACTIVE;
238 IR_dprintk(1, "Sony decode failed at state %d (%uus %s)\n",
239 data->state, TO_US(ev.duration), TO_STR(ev.pulse));
240 data->state = STATE_INACTIVE;
244 static int ir_sony_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_sony_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 sony_handler = {
289 .decode = ir_sony_decode,
290 .raw_register = ir_sony_register,
291 .raw_unregister = ir_sony_unregister,
294 static int __init ir_sony_decode_init(void)
296 ir_raw_handler_register(&sony_handler);
298 printk(KERN_INFO "IR Sony protocol handler initialized\n");
302 static void __exit ir_sony_decode_exit(void)
304 ir_raw_handler_unregister(&sony_handler);
307 module_init(ir_sony_decode_init);
308 module_exit(ir_sony_decode_exit);
310 MODULE_LICENSE("GPL");
311 MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
312 MODULE_DESCRIPTION("Sony IR protocol decoder");