mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
a86d6df84a
The longer the IR timeout, the longer the rc device waits until delivering the trailing space. So, by reducing this timeout, we reduce the delay for the last scancode to be delivered. Note that the lirc daemon disables all protocols, in which case we revert back to the default value. Signed-off-by: Sean Young <sean@mess.org> Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
419 lines
9.9 KiB
C
419 lines
9.9 KiB
C
/* ir-rc6-decoder.c - A decoder for the RC6 IR protocol
|
|
*
|
|
* Copyright (C) 2010 by David Härdeman <david@hardeman.nu>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation version 2 of the License.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "rc-core-priv.h"
|
|
#include <linux/module.h>
|
|
|
|
/*
|
|
* This decoder currently supports:
|
|
* RC6-0-16 (standard toggle bit in header)
|
|
* RC6-6A-20 (no toggle bit)
|
|
* RC6-6A-24 (no toggle bit)
|
|
* RC6-6A-32 (MCE version with toggle bit in body)
|
|
*/
|
|
|
|
#define RC6_UNIT 444444 /* nanosecs */
|
|
#define RC6_HEADER_NBITS 4 /* not including toggle bit */
|
|
#define RC6_0_NBITS 16
|
|
#define RC6_6A_32_NBITS 32
|
|
#define RC6_6A_NBITS 128 /* Variable 8..128 */
|
|
#define RC6_PREFIX_PULSE (6 * RC6_UNIT)
|
|
#define RC6_PREFIX_SPACE (2 * RC6_UNIT)
|
|
#define RC6_BIT_START (1 * RC6_UNIT)
|
|
#define RC6_BIT_END (1 * RC6_UNIT)
|
|
#define RC6_TOGGLE_START (2 * RC6_UNIT)
|
|
#define RC6_TOGGLE_END (2 * RC6_UNIT)
|
|
#define RC6_SUFFIX_SPACE (6 * RC6_UNIT)
|
|
#define RC6_MODE_MASK 0x07 /* for the header bits */
|
|
#define RC6_STARTBIT_MASK 0x08 /* for the header bits */
|
|
#define RC6_6A_MCE_TOGGLE_MASK 0x8000 /* for the body bits */
|
|
#define RC6_6A_LCC_MASK 0xffff0000 /* RC6-6A-32 long customer code mask */
|
|
#define RC6_6A_MCE_CC 0x800f0000 /* MCE customer code */
|
|
#ifndef CHAR_BIT
|
|
#define CHAR_BIT 8 /* Normally in <limits.h> */
|
|
#endif
|
|
|
|
enum rc6_mode {
|
|
RC6_MODE_0,
|
|
RC6_MODE_6A,
|
|
RC6_MODE_UNKNOWN,
|
|
};
|
|
|
|
enum rc6_state {
|
|
STATE_INACTIVE,
|
|
STATE_PREFIX_SPACE,
|
|
STATE_HEADER_BIT_START,
|
|
STATE_HEADER_BIT_END,
|
|
STATE_TOGGLE_START,
|
|
STATE_TOGGLE_END,
|
|
STATE_BODY_BIT_START,
|
|
STATE_BODY_BIT_END,
|
|
STATE_FINISHED,
|
|
};
|
|
|
|
static enum rc6_mode rc6_mode(struct rc6_dec *data)
|
|
{
|
|
switch (data->header & RC6_MODE_MASK) {
|
|
case 0:
|
|
return RC6_MODE_0;
|
|
case 6:
|
|
if (!data->toggle)
|
|
return RC6_MODE_6A;
|
|
/* fall through */
|
|
default:
|
|
return RC6_MODE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ir_rc6_decode() - Decode one RC6 pulse or space
|
|
* @dev: the struct rc_dev descriptor of the device
|
|
* @ev: the struct ir_raw_event descriptor of the pulse/space
|
|
*
|
|
* This function returns -EINVAL if the pulse violates the state machine
|
|
*/
|
|
static int ir_rc6_decode(struct rc_dev *dev, struct ir_raw_event ev)
|
|
{
|
|
struct rc6_dec *data = &dev->raw->rc6;
|
|
u32 scancode;
|
|
u8 toggle;
|
|
enum rc_proto protocol;
|
|
|
|
if (!is_timing_event(ev)) {
|
|
if (ev.reset)
|
|
data->state = STATE_INACTIVE;
|
|
return 0;
|
|
}
|
|
|
|
if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2))
|
|
goto out;
|
|
|
|
again:
|
|
dev_dbg(&dev->dev, "RC6 decode started at state %i (%uus %s)\n",
|
|
data->state, TO_US(ev.duration), TO_STR(ev.pulse));
|
|
|
|
if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2))
|
|
return 0;
|
|
|
|
switch (data->state) {
|
|
|
|
case STATE_INACTIVE:
|
|
if (!ev.pulse)
|
|
break;
|
|
|
|
/* Note: larger margin on first pulse since each RC6_UNIT
|
|
is quite short and some hardware takes some time to
|
|
adjust to the signal */
|
|
if (!eq_margin(ev.duration, RC6_PREFIX_PULSE, RC6_UNIT))
|
|
break;
|
|
|
|
data->state = STATE_PREFIX_SPACE;
|
|
data->count = 0;
|
|
return 0;
|
|
|
|
case STATE_PREFIX_SPACE:
|
|
if (ev.pulse)
|
|
break;
|
|
|
|
if (!eq_margin(ev.duration, RC6_PREFIX_SPACE, RC6_UNIT / 2))
|
|
break;
|
|
|
|
data->state = STATE_HEADER_BIT_START;
|
|
data->header = 0;
|
|
return 0;
|
|
|
|
case STATE_HEADER_BIT_START:
|
|
if (!eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2))
|
|
break;
|
|
|
|
data->header <<= 1;
|
|
if (ev.pulse)
|
|
data->header |= 1;
|
|
data->count++;
|
|
data->state = STATE_HEADER_BIT_END;
|
|
return 0;
|
|
|
|
case STATE_HEADER_BIT_END:
|
|
if (!is_transition(&ev, &dev->raw->prev_ev))
|
|
break;
|
|
|
|
if (data->count == RC6_HEADER_NBITS)
|
|
data->state = STATE_TOGGLE_START;
|
|
else
|
|
data->state = STATE_HEADER_BIT_START;
|
|
|
|
decrease_duration(&ev, RC6_BIT_END);
|
|
goto again;
|
|
|
|
case STATE_TOGGLE_START:
|
|
if (!eq_margin(ev.duration, RC6_TOGGLE_START, RC6_UNIT / 2))
|
|
break;
|
|
|
|
data->toggle = ev.pulse;
|
|
data->state = STATE_TOGGLE_END;
|
|
return 0;
|
|
|
|
case STATE_TOGGLE_END:
|
|
if (!is_transition(&ev, &dev->raw->prev_ev) ||
|
|
!geq_margin(ev.duration, RC6_TOGGLE_END, RC6_UNIT / 2))
|
|
break;
|
|
|
|
if (!(data->header & RC6_STARTBIT_MASK)) {
|
|
dev_dbg(&dev->dev, "RC6 invalid start bit\n");
|
|
break;
|
|
}
|
|
|
|
data->state = STATE_BODY_BIT_START;
|
|
decrease_duration(&ev, RC6_TOGGLE_END);
|
|
data->count = 0;
|
|
data->body = 0;
|
|
|
|
switch (rc6_mode(data)) {
|
|
case RC6_MODE_0:
|
|
data->wanted_bits = RC6_0_NBITS;
|
|
break;
|
|
case RC6_MODE_6A:
|
|
data->wanted_bits = RC6_6A_NBITS;
|
|
break;
|
|
default:
|
|
dev_dbg(&dev->dev, "RC6 unknown mode\n");
|
|
goto out;
|
|
}
|
|
goto again;
|
|
|
|
case STATE_BODY_BIT_START:
|
|
if (eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2)) {
|
|
/* Discard LSB's that won't fit in data->body */
|
|
if (data->count++ < CHAR_BIT * sizeof data->body) {
|
|
data->body <<= 1;
|
|
if (ev.pulse)
|
|
data->body |= 1;
|
|
}
|
|
data->state = STATE_BODY_BIT_END;
|
|
return 0;
|
|
} else if (RC6_MODE_6A == rc6_mode(data) && !ev.pulse &&
|
|
geq_margin(ev.duration, RC6_SUFFIX_SPACE, RC6_UNIT / 2)) {
|
|
data->state = STATE_FINISHED;
|
|
goto again;
|
|
}
|
|
break;
|
|
|
|
case STATE_BODY_BIT_END:
|
|
if (!is_transition(&ev, &dev->raw->prev_ev))
|
|
break;
|
|
|
|
if (data->count == data->wanted_bits)
|
|
data->state = STATE_FINISHED;
|
|
else
|
|
data->state = STATE_BODY_BIT_START;
|
|
|
|
decrease_duration(&ev, RC6_BIT_END);
|
|
goto again;
|
|
|
|
case STATE_FINISHED:
|
|
if (ev.pulse)
|
|
break;
|
|
|
|
switch (rc6_mode(data)) {
|
|
case RC6_MODE_0:
|
|
scancode = data->body;
|
|
toggle = data->toggle;
|
|
protocol = RC_PROTO_RC6_0;
|
|
dev_dbg(&dev->dev, "RC6(0) scancode 0x%04x (toggle: %u)\n",
|
|
scancode, toggle);
|
|
break;
|
|
|
|
case RC6_MODE_6A:
|
|
if (data->count > CHAR_BIT * sizeof data->body) {
|
|
dev_dbg(&dev->dev, "RC6 too many (%u) data bits\n",
|
|
data->count);
|
|
goto out;
|
|
}
|
|
|
|
scancode = data->body;
|
|
switch (data->count) {
|
|
case 20:
|
|
protocol = RC_PROTO_RC6_6A_20;
|
|
toggle = 0;
|
|
break;
|
|
case 24:
|
|
protocol = RC_PROTO_RC6_6A_24;
|
|
toggle = 0;
|
|
break;
|
|
case 32:
|
|
if ((scancode & RC6_6A_LCC_MASK) == RC6_6A_MCE_CC) {
|
|
protocol = RC_PROTO_RC6_MCE;
|
|
toggle = !!(scancode & RC6_6A_MCE_TOGGLE_MASK);
|
|
scancode &= ~RC6_6A_MCE_TOGGLE_MASK;
|
|
} else {
|
|
protocol = RC_PROTO_RC6_6A_32;
|
|
toggle = 0;
|
|
}
|
|
break;
|
|
default:
|
|
dev_dbg(&dev->dev, "RC6(6A) unsupported length\n");
|
|
goto out;
|
|
}
|
|
|
|
dev_dbg(&dev->dev, "RC6(6A) proto 0x%04x, scancode 0x%08x (toggle: %u)\n",
|
|
protocol, scancode, toggle);
|
|
break;
|
|
default:
|
|
dev_dbg(&dev->dev, "RC6 unknown mode\n");
|
|
goto out;
|
|
}
|
|
|
|
rc_keydown(dev, protocol, scancode, toggle);
|
|
data->state = STATE_INACTIVE;
|
|
return 0;
|
|
}
|
|
|
|
out:
|
|
dev_dbg(&dev->dev, "RC6 decode failed at state %i (%uus %s)\n",
|
|
data->state, TO_US(ev.duration), TO_STR(ev.pulse));
|
|
data->state = STATE_INACTIVE;
|
|
return -EINVAL;
|
|
}
|
|
|
|
static const struct ir_raw_timings_manchester ir_rc6_timings[4] = {
|
|
{
|
|
.leader_pulse = RC6_PREFIX_PULSE,
|
|
.leader_space = RC6_PREFIX_SPACE,
|
|
.clock = RC6_UNIT,
|
|
.invert = 1,
|
|
},
|
|
{
|
|
.clock = RC6_UNIT * 2,
|
|
.invert = 1,
|
|
},
|
|
{
|
|
.clock = RC6_UNIT,
|
|
.invert = 1,
|
|
.trailer_space = RC6_SUFFIX_SPACE,
|
|
},
|
|
};
|
|
|
|
/**
|
|
* ir_rc6_encode() - Encode a scancode as a stream of raw events
|
|
*
|
|
* @protocol: protocol to encode
|
|
* @scancode: scancode to encode
|
|
* @events: array of raw ir events to write into
|
|
* @max: maximum size of @events
|
|
*
|
|
* Returns: The number of events written.
|
|
* -ENOBUFS if there isn't enough space in the array to fit the
|
|
* encoding. In this case all @max events will have been written.
|
|
* -EINVAL if the scancode is ambiguous or invalid.
|
|
*/
|
|
static int ir_rc6_encode(enum rc_proto protocol, u32 scancode,
|
|
struct ir_raw_event *events, unsigned int max)
|
|
{
|
|
int ret;
|
|
struct ir_raw_event *e = events;
|
|
|
|
if (protocol == RC_PROTO_RC6_0) {
|
|
/* Modulate the header (Start Bit & Mode-0) */
|
|
ret = ir_raw_gen_manchester(&e, max - (e - events),
|
|
&ir_rc6_timings[0],
|
|
RC6_HEADER_NBITS, (1 << 3));
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Modulate Trailer Bit */
|
|
ret = ir_raw_gen_manchester(&e, max - (e - events),
|
|
&ir_rc6_timings[1], 1, 0);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Modulate rest of the data */
|
|
ret = ir_raw_gen_manchester(&e, max - (e - events),
|
|
&ir_rc6_timings[2], RC6_0_NBITS,
|
|
scancode);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
} else {
|
|
int bits;
|
|
|
|
switch (protocol) {
|
|
case RC_PROTO_RC6_MCE:
|
|
case RC_PROTO_RC6_6A_32:
|
|
bits = 32;
|
|
break;
|
|
case RC_PROTO_RC6_6A_24:
|
|
bits = 24;
|
|
break;
|
|
case RC_PROTO_RC6_6A_20:
|
|
bits = 20;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Modulate the header (Start Bit & Header-version 6 */
|
|
ret = ir_raw_gen_manchester(&e, max - (e - events),
|
|
&ir_rc6_timings[0],
|
|
RC6_HEADER_NBITS, (1 << 3 | 6));
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Modulate Trailer Bit */
|
|
ret = ir_raw_gen_manchester(&e, max - (e - events),
|
|
&ir_rc6_timings[1], 1, 0);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
/* Modulate rest of the data */
|
|
ret = ir_raw_gen_manchester(&e, max - (e - events),
|
|
&ir_rc6_timings[2],
|
|
bits,
|
|
scancode);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
return e - events;
|
|
}
|
|
|
|
static struct ir_raw_handler rc6_handler = {
|
|
.protocols = RC_PROTO_BIT_RC6_0 | RC_PROTO_BIT_RC6_6A_20 |
|
|
RC_PROTO_BIT_RC6_6A_24 | RC_PROTO_BIT_RC6_6A_32 |
|
|
RC_PROTO_BIT_RC6_MCE,
|
|
.decode = ir_rc6_decode,
|
|
.encode = ir_rc6_encode,
|
|
.carrier = 36000,
|
|
.min_timeout = RC6_SUFFIX_SPACE,
|
|
};
|
|
|
|
static int __init ir_rc6_decode_init(void)
|
|
{
|
|
ir_raw_handler_register(&rc6_handler);
|
|
|
|
printk(KERN_INFO "IR RC6 protocol handler initialized\n");
|
|
return 0;
|
|
}
|
|
|
|
static void __exit ir_rc6_decode_exit(void)
|
|
{
|
|
ir_raw_handler_unregister(&rc6_handler);
|
|
}
|
|
|
|
module_init(ir_rc6_decode_init);
|
|
module_exit(ir_rc6_decode_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
|
|
MODULE_DESCRIPTION("RC6 IR protocol decoder");
|