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)) {
114 IR_dprintk(1, "SANYO repeat last key\n");
115 data->state = STATE_INACTIVE;
120 if (eq_margin(ev.duration, SANYO_BIT_1_SPACE, SANYO_UNIT / 2))
122 else if (!eq_margin(ev.duration, SANYO_BIT_0_SPACE, SANYO_UNIT / 2))
126 if (data->count == SANYO_NBITS)
127 data->state = STATE_TRAILER_PULSE;
129 data->state = STATE_BIT_PULSE;
133 case STATE_TRAILER_PULSE:
137 if (!eq_margin(ev.duration, SANYO_TRAILER_PULSE, SANYO_UNIT / 2))
140 data->state = STATE_TRAILER_SPACE;
143 case STATE_TRAILER_SPACE:
147 if (!geq_margin(ev.duration, SANYO_TRAILER_SPACE, SANYO_UNIT / 2))
150 address = bitrev16((data->bits >> 29) & 0x1fff) >> 3;
151 /* not_address = bitrev16((data->bits >> 16) & 0x1fff) >> 3; */
152 command = bitrev8((data->bits >> 8) & 0xff);
153 not_command = bitrev8((data->bits >> 0) & 0xff);
155 if ((command ^ not_command) != 0xff) {
156 IR_dprintk(1, "SANYO checksum error: received 0x%08Lx\n",
158 data->state = STATE_INACTIVE;
162 scancode = address << 8 | command;
163 IR_dprintk(1, "SANYO scancode: 0x%06x\n", scancode);
164 rc_keydown(dev, RC_PROTO_SANYO, scancode, 0);
165 data->state = STATE_INACTIVE;
169 IR_dprintk(1, "SANYO decode failed at count %d state %d (%uus %s)\n",
170 data->count, data->state, TO_US(ev.duration), TO_STR(ev.pulse));
171 data->state = STATE_INACTIVE;
175 static const struct ir_raw_timings_pd ir_sanyo_timings = {
176 .header_pulse = SANYO_HEADER_PULSE,
177 .header_space = SANYO_HEADER_SPACE,
178 .bit_pulse = SANYO_BIT_PULSE,
179 .bit_space[0] = SANYO_BIT_0_SPACE,
180 .bit_space[1] = SANYO_BIT_1_SPACE,
181 .trailer_pulse = SANYO_TRAILER_PULSE,
182 .trailer_space = SANYO_TRAILER_SPACE,
187 * ir_sanyo_encode() - Encode a scancode as a stream of raw events
189 * @protocol: protocol to encode
190 * @scancode: scancode to encode
191 * @events: array of raw ir events to write into
192 * @max: maximum size of @events
194 * Returns: The number of events written.
195 * -ENOBUFS if there isn't enough space in the array to fit the
196 * encoding. In this case all @max events will have been written.
198 static int ir_sanyo_encode(enum rc_proto protocol, u32 scancode,
199 struct ir_raw_event *events, unsigned int max)
201 struct ir_raw_event *e = events;
205 raw = ((u64)(bitrev16(scancode >> 8) & 0xfff8) << (8 + 8 + 13 - 3)) |
206 ((u64)(bitrev16(~scancode >> 8) & 0xfff8) << (8 + 8 + 0 - 3)) |
207 ((bitrev8(scancode) & 0xff) << 8) |
208 (bitrev8(~scancode) & 0xff);
210 ret = ir_raw_gen_pd(&e, max, &ir_sanyo_timings, SANYO_NBITS, raw);
217 static struct ir_raw_handler sanyo_handler = {
218 .protocols = RC_PROTO_BIT_SANYO,
219 .decode = ir_sanyo_decode,
220 .encode = ir_sanyo_encode,
223 static int __init ir_sanyo_decode_init(void)
225 ir_raw_handler_register(&sanyo_handler);
227 printk(KERN_INFO "IR SANYO protocol handler initialized\n");
231 static void __exit ir_sanyo_decode_exit(void)
233 ir_raw_handler_unregister(&sanyo_handler);
236 module_init(ir_sanyo_decode_init);
237 module_exit(ir_sanyo_decode_exit);
239 MODULE_LICENSE("GPL");
240 MODULE_AUTHOR("Mauro Carvalho Chehab");
241 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
242 MODULE_DESCRIPTION("SANYO IR protocol decoder");