]> git.karo-electronics.de Git - mv-sheeva.git/blob - drivers/media/IR/ir-rc5-decoder.c
Merge branch 'rs485fix' of git://www.jni.nu/cris
[mv-sheeva.git] / drivers / media / IR / ir-rc5-decoder.c
1 /* ir-rc5-decoder.c - handle RC5(x) IR Pulse/Space protocol
2  *
3  * Copyright (C) 2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
4  *
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.
8  *
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.
13  */
14
15 /*
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
21  */
22
23 #include "ir-core-priv.h"
24
25 #define RC5_NBITS               14
26 #define RC5X_NBITS              20
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)
32
33 enum rc5_state {
34         STATE_INACTIVE,
35         STATE_BIT_START,
36         STATE_BIT_END,
37         STATE_CHECK_RC5X,
38         STATE_FINISHED,
39 };
40
41 /**
42  * ir_rc5_decode() - Decode one RC-5 pulse or space
43  * @input_dev:  the struct input_dev descriptor of the device
44  * @ev:         the struct ir_raw_event descriptor of the pulse/space
45  *
46  * This function returns -EINVAL if the pulse violates the state machine
47  */
48 static int ir_rc5_decode(struct input_dev *input_dev, struct ir_raw_event ev)
49 {
50         struct ir_input_dev *ir_dev = input_get_drvdata(input_dev);
51         struct rc5_dec *data = &ir_dev->raw->rc5;
52         u8 toggle;
53         u32 scancode;
54
55         if (!(ir_dev->raw->enabled_protocols & IR_TYPE_RC5))
56                 return 0;
57
58         if (IS_RESET(ev)) {
59                 data->state = STATE_INACTIVE;
60                 return 0;
61         }
62
63         if (!geq_margin(ev.duration, RC5_UNIT, RC5_UNIT / 2))
64                 goto out;
65
66 again:
67         IR_dprintk(2, "RC5(x) decode started at state %i (%uus %s)\n",
68                    data->state, TO_US(ev.duration), TO_STR(ev.pulse));
69
70         if (!geq_margin(ev.duration, RC5_UNIT, RC5_UNIT / 2))
71                 return 0;
72
73         switch (data->state) {
74
75         case STATE_INACTIVE:
76                 if (!ev.pulse)
77                         break;
78
79                 data->state = STATE_BIT_START;
80                 data->count = 1;
81                 /* We just need enough bits to get to STATE_CHECK_RC5X */
82                 data->wanted_bits = RC5X_NBITS;
83                 decrease_duration(&ev, RC5_BIT_START);
84                 goto again;
85
86         case STATE_BIT_START:
87                 if (!eq_margin(ev.duration, RC5_BIT_START, RC5_UNIT / 2))
88                         break;
89
90                 data->bits <<= 1;
91                 if (!ev.pulse)
92                         data->bits |= 1;
93                 data->count++;
94                 data->state = STATE_BIT_END;
95                 return 0;
96
97         case STATE_BIT_END:
98                 if (!is_transition(&ev, &ir_dev->raw->prev_ev))
99                         break;
100
101                 if (data->count == data->wanted_bits)
102                         data->state = STATE_FINISHED;
103                 else if (data->count == CHECK_RC5X_NBITS)
104                         data->state = STATE_CHECK_RC5X;
105                 else
106                         data->state = STATE_BIT_START;
107
108                 decrease_duration(&ev, RC5_BIT_END);
109                 goto again;
110
111         case STATE_CHECK_RC5X:
112                 if (!ev.pulse && geq_margin(ev.duration, RC5X_SPACE, RC5_UNIT / 2)) {
113                         /* RC5X */
114                         data->wanted_bits = RC5X_NBITS;
115                         decrease_duration(&ev, RC5X_SPACE);
116                 } else {
117                         /* RC5 */
118                         data->wanted_bits = RC5_NBITS;
119                 }
120                 data->state = STATE_BIT_START;
121                 goto again;
122
123         case STATE_FINISHED:
124                 if (ev.pulse)
125                         break;
126
127                 if (data->wanted_bits == RC5X_NBITS) {
128                         /* RC5X */
129                         u8 xdata, command, system;
130                         xdata    = (data->bits & 0x0003F) >> 0;
131                         command  = (data->bits & 0x00FC0) >> 6;
132                         system   = (data->bits & 0x1F000) >> 12;
133                         toggle   = (data->bits & 0x20000) ? 1 : 0;
134                         command += (data->bits & 0x01000) ? 0 : 0x40;
135                         scancode = system << 16 | command << 8 | xdata;
136
137                         IR_dprintk(1, "RC5X scancode 0x%06x (toggle: %u)\n",
138                                    scancode, toggle);
139
140                 } else {
141                         /* RC5 */
142                         u8 command, system;
143                         command  = (data->bits & 0x0003F) >> 0;
144                         system   = (data->bits & 0x007C0) >> 6;
145                         toggle   = (data->bits & 0x00800) ? 1 : 0;
146                         command += (data->bits & 0x01000) ? 0 : 0x40;
147                         scancode = system << 8 | command;
148
149                         IR_dprintk(1, "RC5 scancode 0x%04x (toggle: %u)\n",
150                                    scancode, toggle);
151                 }
152
153                 ir_keydown(input_dev, scancode, toggle);
154                 data->state = STATE_INACTIVE;
155                 return 0;
156         }
157
158 out:
159         IR_dprintk(1, "RC5(x) decode failed at state %i (%uus %s)\n",
160                    data->state, TO_US(ev.duration), TO_STR(ev.pulse));
161         data->state = STATE_INACTIVE;
162         return -EINVAL;
163 }
164
165 static struct ir_raw_handler rc5_handler = {
166         .protocols      = IR_TYPE_RC5,
167         .decode         = ir_rc5_decode,
168 };
169
170 static int __init ir_rc5_decode_init(void)
171 {
172         ir_raw_handler_register(&rc5_handler);
173
174         printk(KERN_INFO "IR RC5(x) protocol handler initialized\n");
175         return 0;
176 }
177
178 static void __exit ir_rc5_decode_exit(void)
179 {
180         ir_raw_handler_unregister(&rc5_handler);
181 }
182
183 module_init(ir_rc5_decode_init);
184 module_exit(ir_rc5_decode_exit);
185
186 MODULE_LICENSE("GPL");
187 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
188 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
189 MODULE_DESCRIPTION("RC5(x) IR protocol decoder");