1 /* ir-sanyo-decoder.c - handle SANYO IR Pulse/Space protocol
3 * Copyright (C) 2011 by Mauro Carvalho Chehab
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.
14 * This protocol uses the NEC protocol timings. However, data is formatted as:
16 * 13 bits NOT(Custom Code)
18 * 8 bits NOT(Key data)
20 * According with LIRC, this protocol is used on Sanyo, Aiwa and Chinon
21 * Information for this protocol is available at the Sanyo LC7461 datasheet.
24 #include <linux/module.h>
25 #include <linux/bitrev.h>
26 #include "rc-core-priv.h"
28 #define SANYO_NBITS (13+13+8+8)
29 #define SANYO_UNIT 562500 /* ns */
30 #define SANYO_HEADER_PULSE (16 * SANYO_UNIT)
31 #define SANYO_HEADER_SPACE (8 * SANYO_UNIT)
32 #define SANYO_BIT_PULSE (1 * SANYO_UNIT)
33 #define SANYO_BIT_0_SPACE (1 * SANYO_UNIT)
34 #define SANYO_BIT_1_SPACE (3 * SANYO_UNIT)
35 #define SANYO_REPEAT_SPACE (150 * SANYO_UNIT)
36 #define SANYO_TRAILER_PULSE (1 * SANYO_UNIT)
37 #define SANYO_TRAILER_SPACE (10 * SANYO_UNIT) /* in fact, 42 */
49 * ir_sanyo_decode() - Decode one SANYO pulse or space
50 * @dev: the struct rc_dev descriptor of the device
51 * @duration: the struct ir_raw_event descriptor of the pulse/space
53 * This function returns -EINVAL if the pulse violates the state machine
55 static int ir_sanyo_decode(struct rc_dev
*dev
, struct ir_raw_event ev
)
57 struct sanyo_dec
*data
= &dev
->raw
->sanyo
;
60 u8 command
, not_command
;
62 if (!is_timing_event(ev
)) {
64 IR_dprintk(1, "SANYO event reset received. reset to state 0\n");
65 data
->state
= STATE_INACTIVE
;
70 IR_dprintk(2, "SANYO decode started at state %d (%uus %s)\n",
71 data
->state
, TO_US(ev
.duration
), TO_STR(ev
.pulse
));
73 switch (data
->state
) {
79 if (eq_margin(ev
.duration
, SANYO_HEADER_PULSE
, SANYO_UNIT
/ 2)) {
81 data
->state
= STATE_HEADER_SPACE
;
87 case STATE_HEADER_SPACE
:
91 if (eq_margin(ev
.duration
, SANYO_HEADER_SPACE
, SANYO_UNIT
/ 2)) {
92 data
->state
= STATE_BIT_PULSE
;
102 if (!eq_margin(ev
.duration
, SANYO_BIT_PULSE
, SANYO_UNIT
/ 2))
105 data
->state
= STATE_BIT_SPACE
;
108 case STATE_BIT_SPACE
:
112 if (!data
->count
&& geq_margin(ev
.duration
, SANYO_REPEAT_SPACE
, SANYO_UNIT
/ 2)) {
113 if (!dev
->keypressed
) {
114 IR_dprintk(1, "SANYO discarding last key repeat: event after key up\n");
117 IR_dprintk(1, "SANYO repeat last key\n");
118 data
->state
= STATE_INACTIVE
;
124 if (eq_margin(ev
.duration
, SANYO_BIT_1_SPACE
, SANYO_UNIT
/ 2))
126 else if (!eq_margin(ev
.duration
, SANYO_BIT_0_SPACE
, SANYO_UNIT
/ 2))
130 if (data
->count
== SANYO_NBITS
)
131 data
->state
= STATE_TRAILER_PULSE
;
133 data
->state
= STATE_BIT_PULSE
;
137 case STATE_TRAILER_PULSE
:
141 if (!eq_margin(ev
.duration
, SANYO_TRAILER_PULSE
, SANYO_UNIT
/ 2))
144 data
->state
= STATE_TRAILER_SPACE
;
147 case STATE_TRAILER_SPACE
:
151 if (!geq_margin(ev
.duration
, SANYO_TRAILER_SPACE
, SANYO_UNIT
/ 2))
154 address
= bitrev16((data
->bits
>> 29) & 0x1fff) >> 3;
155 /* not_address = bitrev16((data->bits >> 16) & 0x1fff) >> 3; */
156 command
= bitrev8((data
->bits
>> 8) & 0xff);
157 not_command
= bitrev8((data
->bits
>> 0) & 0xff);
159 if ((command
^ not_command
) != 0xff) {
160 IR_dprintk(1, "SANYO checksum error: received 0x%08Lx\n",
162 data
->state
= STATE_INACTIVE
;
166 scancode
= address
<< 8 | command
;
167 IR_dprintk(1, "SANYO scancode: 0x%06x\n", scancode
);
168 rc_keydown(dev
, RC_TYPE_SANYO
, scancode
, 0);
169 data
->state
= STATE_INACTIVE
;
173 IR_dprintk(1, "SANYO decode failed at count %d state %d (%uus %s)\n",
174 data
->count
, data
->state
, TO_US(ev
.duration
), TO_STR(ev
.pulse
));
175 data
->state
= STATE_INACTIVE
;
179 static const struct ir_raw_timings_pd ir_sanyo_timings
= {
180 .header_pulse
= SANYO_HEADER_PULSE
,
181 .header_space
= SANYO_HEADER_SPACE
,
182 .bit_pulse
= SANYO_BIT_PULSE
,
183 .bit_space
[0] = SANYO_BIT_0_SPACE
,
184 .bit_space
[1] = SANYO_BIT_1_SPACE
,
185 .trailer_pulse
= SANYO_TRAILER_PULSE
,
186 .trailer_space
= SANYO_TRAILER_SPACE
,
191 * ir_sanyo_encode() - Encode a scancode as a stream of raw events
193 * @protocol: protocol to encode
194 * @scancode: scancode to encode
195 * @events: array of raw ir events to write into
196 * @max: maximum size of @events
198 * Returns: The number of events written.
199 * -ENOBUFS if there isn't enough space in the array to fit the
200 * encoding. In this case all @max events will have been written.
202 static int ir_sanyo_encode(enum rc_type protocol
, u32 scancode
,
203 struct ir_raw_event
*events
, unsigned int max
)
205 struct ir_raw_event
*e
= events
;
209 raw
= ((u64
)(bitrev16(scancode
>> 8) & 0xfff8) << (8 + 8 + 13 - 3)) |
210 ((u64
)(bitrev16(~scancode
>> 8) & 0xfff8) << (8 + 8 + 0 - 3)) |
211 ((bitrev8(scancode
) & 0xff) << 8) |
212 (bitrev8(~scancode
) & 0xff);
214 ret
= ir_raw_gen_pd(&e
, max
, &ir_sanyo_timings
, SANYO_NBITS
, raw
);
221 static struct ir_raw_handler sanyo_handler
= {
222 .protocols
= RC_BIT_SANYO
,
223 .decode
= ir_sanyo_decode
,
224 .encode
= ir_sanyo_encode
,
227 static int __init
ir_sanyo_decode_init(void)
229 ir_raw_handler_register(&sanyo_handler
);
231 printk(KERN_INFO
"IR SANYO protocol handler initialized\n");
235 static void __exit
ir_sanyo_decode_exit(void)
237 ir_raw_handler_unregister(&sanyo_handler
);
240 module_init(ir_sanyo_decode_init
);
241 module_exit(ir_sanyo_decode_exit
);
243 MODULE_LICENSE("GPL");
244 MODULE_AUTHOR("Mauro Carvalho Chehab");
245 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
246 MODULE_DESCRIPTION("SANYO IR protocol decoder");