[mirror_ubuntu-artful-kernel.git] / drivers / media / rc / ir-rc6-decoder.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_type 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:
	IR_dprintk(2, "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)) {
			IR_dprintk(1, "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:
			IR_dprintk(1, "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_TYPE_RC6_0;
			IR_dprintk(1, "RC6(0) scancode 0x%04x (toggle: %u)\n",
				   scancode, toggle);
			break;

		case RC6_MODE_6A:
			if (data->count > CHAR_BIT * sizeof data->body) {
				IR_dprintk(1, "RC6 too many (%u) data bits\n",
					data->count);
				goto out;
			}

			scancode = data->body;
			switch (data->count) {
			case 20:
				protocol = RC_TYPE_RC6_6A_20;
				toggle = 0;
				break;
			case 24:
				protocol = RC_TYPE_RC6_6A_24;
				toggle = 0;
				break;
			case 32:
				if ((scancode & RC6_6A_LCC_MASK) == RC6_6A_MCE_CC) {
					protocol = RC_TYPE_RC6_MCE;
					toggle = !!(scancode & RC6_6A_MCE_TOGGLE_MASK);
					scancode &= ~RC6_6A_MCE_TOGGLE_MASK;
				} else {
					protocol = RC_TYPE_RC6_6A_32;
					toggle = 0;
				}
				break;
			default:
				IR_dprintk(1, "RC6(6A) unsupported length\n");
				goto out;
			}

			IR_dprintk(1, "RC6(6A) proto 0x%04x, scancode 0x%08x (toggle: %u)\n",
				   protocol, scancode, toggle);
			break;
		default:
			IR_dprintk(1, "RC6 unknown mode\n");
			goto out;
		}

		rc_keydown(dev, protocol, scancode, toggle);
		data->state = STATE_INACTIVE;
		return 0;
	}

out:
	IR_dprintk(1, "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			= RC6_PREFIX_PULSE,
		.pulse_space_start	= 0,
		.clock			= RC6_UNIT,
		.invert			= 1,
		.trailer_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_type protocol, u32 scancode,
			 struct ir_raw_event *events, unsigned int max)
{
	int ret;
	struct ir_raw_event *e = events;

	if (protocol == RC_TYPE_RC6_0) {
		/* Modulate the preamble */
		ret = ir_raw_gen_manchester(&e, max, &ir_rc6_timings[0], 0, 0);
		if (ret < 0)
			return ret;

		/* Modulate the header (Start Bit & Mode-0) */
		ret = ir_raw_gen_manchester(&e, max - (e - events),
					    &ir_rc6_timings[1],
					    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[2], 1, 0);
		if (ret < 0)
			return ret;

		/* Modulate rest of the data */
		ret = ir_raw_gen_manchester(&e, max - (e - events),
					    &ir_rc6_timings[3], RC6_0_NBITS,
					    scancode);
		if (ret < 0)
			return ret;

	} else {
		int bits;

		switch (protocol) {
		case RC_TYPE_RC6_MCE:
		case RC_TYPE_RC6_6A_32:
			bits = 32;
			break;
		case RC_TYPE_RC6_6A_24:
			bits = 24;
			break;
		case RC_TYPE_RC6_6A_20:
			bits = 20;
			break;
		default:
			return -EINVAL;
		}

		/* Modulate the preamble */
		ret = ir_raw_gen_manchester(&e, max, &ir_rc6_timings[0], 0, 0);
		if (ret < 0)
			return ret;

		/* Modulate the header (Start Bit & Header-version 6 */
		ret = ir_raw_gen_manchester(&e, max - (e - events),
					    &ir_rc6_timings[1],
					    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[2], 1, 0);
		if (ret < 0)
			return ret;

		/* Modulate rest of the data */
		ret = ir_raw_gen_manchester(&e, max - (e - events),
					    &ir_rc6_timings[3],
					    bits,
					    scancode);
		if (ret < 0)
			return ret;
	}

	return e - events;
}

static struct ir_raw_handler rc6_handler = {
	.protocols	= RC_BIT_RC6_0 | RC_BIT_RC6_6A_20 |
			  RC_BIT_RC6_6A_24 | RC_BIT_RC6_6A_32 |
			  RC_BIT_RC6_MCE,
	.decode		= ir_rc6_decode,
	.encode		= ir_rc6_encode,
};

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");
Commit	Line	Data
784a4931 DH	1	/* ir-rc6-decoder.c - A decoder for the RC6 IR protocol
	2	*
	3	* Copyright (C) 2010 by David Härdeman <david@hardeman.nu>
	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
f62de675	15	#include "rc-core-priv.h"
7a707b89	16	#include <linux/module.h>
784a4931 DH	17
	18	/*
	19	* This decoder currently supports:
	20	* RC6-0-16 (standard toggle bit in header)
db9bc660	21	* RC6-6A-20 (no toggle bit)
784a4931 DH	22	* RC6-6A-24 (no toggle bit)
	23	* RC6-6A-32 (MCE version with toggle bit in body)
	24	*/
	25
db9bc660	26	#define RC6_UNIT 444444 /* nanosecs */
784a4931 DH	27	#define RC6_HEADER_NBITS 4 /* not including toggle bit */
784a4931 DH	28	#define RC6_0_NBITS 16
db9bc660	29	#define RC6_6A_32_NBITS 32
db9bc660	30	#define RC6_6A_NBITS 128 /* Variable 8..128 */
e40b1127 DH	31	#define RC6_PREFIX_PULSE (6 * RC6_UNIT)
	32	#define RC6_PREFIX_SPACE (2 * RC6_UNIT)
	33	#define RC6_BIT_START (1 * RC6_UNIT)
	34	#define RC6_BIT_END (1 * RC6_UNIT)
	35	#define RC6_TOGGLE_START (2 * RC6_UNIT)
	36	#define RC6_TOGGLE_END (2 * RC6_UNIT)
db9bc660	37	#define RC6_SUFFIX_SPACE (6 * RC6_UNIT)
784a4931 DH	38	#define RC6_MODE_MASK 0x07 /* for the header bits */
	39	#define RC6_STARTBIT_MASK 0x08 /* for the header bits */
	40	#define RC6_6A_MCE_TOGGLE_MASK 0x8000 /* for the body bits */
db9bc660	41	#define RC6_6A_LCC_MASK 0xffff0000 /* RC6-6A-32 long customer code mask */
	42	#define RC6_6A_MCE_CC 0x800f0000 /* MCE customer code */
	43	#ifndef CHAR_BIT
	44	#define CHAR_BIT 8 /* Normally in <limits.h> */
	45	#endif
784a4931	46
784a4931 DH	47	enum rc6_mode {
	48	RC6_MODE_0,
	49	RC6_MODE_6A,
	50	RC6_MODE_UNKNOWN,
	51	};
	52
	53	enum rc6_state {
	54	STATE_INACTIVE,
	55	STATE_PREFIX_SPACE,
	56	STATE_HEADER_BIT_START,
	57	STATE_HEADER_BIT_END,
	58	STATE_TOGGLE_START,
	59	STATE_TOGGLE_END,
	60	STATE_BODY_BIT_START,
	61	STATE_BODY_BIT_END,
	62	STATE_FINISHED,
	63	};
	64
c216369e	65	static enum rc6_mode rc6_mode(struct rc6_dec *data)
784a4931	66	{
784a4931 DH	67	switch (data->header & RC6_MODE_MASK) {
	68	case 0:
	69	return RC6_MODE_0;
	70	case 6:
	71	if (!data->toggle)
	72	return RC6_MODE_6A;
	73	/* fall through */
	74	default:
	75	return RC6_MODE_UNKNOWN;
	76	}
	77	}
	78
	79	/**
	80	* ir_rc6_decode() - Decode one RC6 pulse or space
d8b4b582	81	* @dev: the struct rc_dev descriptor of the device
e40b1127	82	* @ev: the struct ir_raw_event descriptor of the pulse/space
784a4931 DH	83	*
	84	* This function returns -EINVAL if the pulse violates the state machine
	85	*/
d8b4b582	86	static int ir_rc6_decode(struct rc_dev *dev, struct ir_raw_event ev)
784a4931	87	{
d8b4b582	88	struct rc6_dec *data = &dev->raw->rc6;
784a4931 DH	89	u32 scancode;
784a4931 DH	90	u8 toggle;
120703f9	91	enum rc_type protocol;
784a4931	92
4651918a ML	93	if (!is_timing_event(ev)) {
	94	if (ev.reset)
	95	data->state = STATE_INACTIVE;
784a4931 DH	96	return 0;
	97	}
	98
e40b1127	99	if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2))
784a4931 DH	100	goto out;
	101
	102	again:
e40b1127 DH	103	IR_dprintk(2, "RC6 decode started at state %i (%uus %s)\n",
e40b1127 DH	104	data->state, TO_US(ev.duration), TO_STR(ev.pulse));
784a4931	105
e40b1127	106	if (!geq_margin(ev.duration, RC6_UNIT, RC6_UNIT / 2))
784a4931 DH	107	return 0;
	108
	109	switch (data->state) {
	110
	111	case STATE_INACTIVE:
e40b1127 DH	112	if (!ev.pulse)
	113	break;
	114
	115	/* Note: larger margin on first pulse since each RC6_UNIT
	116	is quite short and some hardware takes some time to
	117	adjust to the signal */
	118	if (!eq_margin(ev.duration, RC6_PREFIX_PULSE, RC6_UNIT))
	119	break;
	120
	121	data->state = STATE_PREFIX_SPACE;
	122	data->count = 0;
	123	return 0;
784a4931 DH	124
784a4931 DH	125	case STATE_PREFIX_SPACE:
e40b1127 DH	126	if (ev.pulse)
	127	break;
	128
	129	if (!eq_margin(ev.duration, RC6_PREFIX_SPACE, RC6_UNIT / 2))
	130	break;
	131
	132	data->state = STATE_HEADER_BIT_START;
db9bc660	133	data->header = 0;
e40b1127	134	return 0;
784a4931 DH	135
784a4931 DH	136	case STATE_HEADER_BIT_START:
e40b1127 DH	137	if (!eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2))
	138	break;
	139
	140	data->header <<= 1;
	141	if (ev.pulse)
	142	data->header \|= 1;
	143	data->count++;
e40b1127 DH	144	data->state = STATE_HEADER_BIT_END;
e40b1127 DH	145	return 0;
784a4931 DH	146
784a4931 DH	147	case STATE_HEADER_BIT_END:
d8b4b582	148	if (!is_transition(&ev, &dev->raw->prev_ev))
e40b1127	149	break;
784a4931	150
e40b1127 DH	151	if (data->count == RC6_HEADER_NBITS)
	152	data->state = STATE_TOGGLE_START;
	153	else
	154	data->state = STATE_HEADER_BIT_START;
	155
	156	decrease_duration(&ev, RC6_BIT_END);
	157	goto again;
784a4931 DH	158
784a4931 DH	159	case STATE_TOGGLE_START:
e40b1127 DH	160	if (!eq_margin(ev.duration, RC6_TOGGLE_START, RC6_UNIT / 2))
	161	break;
	162
	163	data->toggle = ev.pulse;
e40b1127 DH	164	data->state = STATE_TOGGLE_END;
e40b1127 DH	165	return 0;
784a4931 DH	166
784a4931 DH	167	case STATE_TOGGLE_END:
d8b4b582	168	if (!is_transition(&ev, &dev->raw->prev_ev) \|\|
e40b1127 DH	169	!geq_margin(ev.duration, RC6_TOGGLE_END, RC6_UNIT / 2))
e40b1127 DH	170	break;
784a4931	171
e40b1127 DH	172	if (!(data->header & RC6_STARTBIT_MASK)) {
	173	IR_dprintk(1, "RC6 invalid start bit\n");
	174	break;
	175	}
784a4931	176
e40b1127	177	data->state = STATE_BODY_BIT_START;
e40b1127 DH	178	decrease_duration(&ev, RC6_TOGGLE_END);
e40b1127 DH	179	data->count = 0;
db9bc660	180	data->body = 0;
e40b1127 DH	181
	182	switch (rc6_mode(data)) {
	183	case RC6_MODE_0:
	184	data->wanted_bits = RC6_0_NBITS;
	185	break;
	186	case RC6_MODE_6A:
db9bc660	187	data->wanted_bits = RC6_6A_NBITS;
e40b1127 DH	188	break;
	189	default:
	190	IR_dprintk(1, "RC6 unknown mode\n");
	191	goto out;
784a4931	192	}
e40b1127	193	goto again;
784a4931 DH	194
784a4931 DH	195	case STATE_BODY_BIT_START:
db9bc660	196	if (eq_margin(ev.duration, RC6_BIT_START, RC6_UNIT / 2)) {
	197	/* Discard LSB's that won't fit in data->body */
	198	if (data->count++ < CHAR_BIT * sizeof data->body) {
	199	data->body <<= 1;
	200	if (ev.pulse)
	201	data->body \|= 1;
	202	}
	203	data->state = STATE_BODY_BIT_END;
	204	return 0;
	205	} else if (RC6_MODE_6A == rc6_mode(data) && !ev.pulse &&
	206	geq_margin(ev.duration, RC6_SUFFIX_SPACE, RC6_UNIT / 2)) {
	207	data->state = STATE_FINISHED;
	208	goto again;
	209	}
	210	break;
784a4931 DH	211
784a4931 DH	212	case STATE_BODY_BIT_END:
d8b4b582	213	if (!is_transition(&ev, &dev->raw->prev_ev))
e40b1127	214	break;
784a4931	215
e40b1127 DH	216	if (data->count == data->wanted_bits)
	217	data->state = STATE_FINISHED;
	218	else
	219	data->state = STATE_BODY_BIT_START;
	220
	221	decrease_duration(&ev, RC6_BIT_END);
	222	goto again;
784a4931 DH	223
784a4931 DH	224	case STATE_FINISHED:
e40b1127 DH	225	if (ev.pulse)
	226	break;
	227
784a4931 DH	228	switch (rc6_mode(data)) {
784a4931 DH	229	case RC6_MODE_0:
db9bc660	230	scancode = data->body;
784a4931	231	toggle = data->toggle;
120703f9	232	protocol = RC_TYPE_RC6_0;
784a4931 DH	233	IR_dprintk(1, "RC6(0) scancode 0x%04x (toggle: %u)\n",
	234	scancode, toggle);
	235	break;
120703f9	236
784a4931	237	case RC6_MODE_6A:
db9bc660	238	if (data->count > CHAR_BIT * sizeof data->body) {
	239	IR_dprintk(1, "RC6 too many (%u) data bits\n",
	240	data->count);
	241	goto out;
	242	}
	243
	244	scancode = data->body;
120703f9 DH	245	switch (data->count) {
	246	case 20:
	247	protocol = RC_TYPE_RC6_6A_20;
	248	toggle = 0;
	249	break;
	250	case 24:
e998c92d	251	protocol = RC_TYPE_RC6_6A_24;
784a4931	252	toggle = 0;
120703f9 DH	253	break;
	254	case 32:
	255	if ((scancode & RC6_6A_LCC_MASK) == RC6_6A_MCE_CC) {
	256	protocol = RC_TYPE_RC6_MCE;
120703f9	257	toggle = !!(scancode & RC6_6A_MCE_TOGGLE_MASK);
d2a74581	258	scancode &= ~RC6_6A_MCE_TOGGLE_MASK;
120703f9	259	} else {
e998c92d	260	protocol = RC_TYPE_RC6_6A_32;
120703f9 DH	261	toggle = 0;
	262	}
	263	break;
	264	default:
	265	IR_dprintk(1, "RC6(6A) unsupported length\n");
	266	goto out;
784a4931	267	}
120703f9 DH	268
	269	IR_dprintk(1, "RC6(6A) proto 0x%04x, scancode 0x%08x (toggle: %u)\n",
	270	protocol, scancode, toggle);
784a4931 DH	271	break;
	272	default:
	273	IR_dprintk(1, "RC6 unknown mode\n");
	274	goto out;
	275	}
	276
120703f9	277	rc_keydown(dev, protocol, scancode, toggle);
784a4931 DH	278	data->state = STATE_INACTIVE;
	279	return 0;
	280	}
	281
	282	out:
e40b1127 DH	283	IR_dprintk(1, "RC6 decode failed at state %i (%uus %s)\n",
e40b1127 DH	284	data->state, TO_US(ev.duration), TO_STR(ev.pulse));
784a4931 DH	285	data->state = STATE_INACTIVE;
	286	return -EINVAL;
	287	}
	288
9d974e49 AS	289	static const struct ir_raw_timings_manchester ir_rc6_timings[4] = {
	290	{
	291	.leader = RC6_PREFIX_PULSE,
	292	.pulse_space_start = 0,
	293	.clock = RC6_UNIT,
	294	.invert = 1,
	295	.trailer_space = RC6_PREFIX_SPACE,
	296	},
	297	{
	298	.clock = RC6_UNIT,
	299	.invert = 1,
	300	},
	301	{
	302	.clock = RC6_UNIT * 2,
	303	.invert = 1,
	304	},
	305	{
	306	.clock = RC6_UNIT,
	307	.invert = 1,
	308	.trailer_space = RC6_SUFFIX_SPACE,
	309	},
	310	};
	311
	312	/**
	313	* ir_rc6_encode() - Encode a scancode as a stream of raw events
	314	*
	315	* @protocol: protocol to encode
	316	* @scancode: scancode to encode
	317	* @events: array of raw ir events to write into
	318	* @max: maximum size of @events
	319	*
	320	* Returns: The number of events written.
	321	* -ENOBUFS if there isn't enough space in the array to fit the
	322	* encoding. In this case all @max events will have been written.
	323	* -EINVAL if the scancode is ambiguous or invalid.
	324	*/
	325	static int ir_rc6_encode(enum rc_type protocol, u32 scancode,
	326	struct ir_raw_event *events, unsigned int max)
	327	{
	328	int ret;
	329	struct ir_raw_event *e = events;
	330
	331	if (protocol == RC_TYPE_RC6_0) {
	332	/* Modulate the preamble */
	333	ret = ir_raw_gen_manchester(&e, max, &ir_rc6_timings[0], 0, 0);
	334	if (ret < 0)
	335	return ret;
	336
	337	/* Modulate the header (Start Bit & Mode-0) */
	338	ret = ir_raw_gen_manchester(&e, max - (e - events),
	339	&ir_rc6_timings[1],
	340	RC6_HEADER_NBITS, (1 << 3));
	341	if (ret < 0)
	342	return ret;
	343
	344	/* Modulate Trailer Bit */
	345	ret = ir_raw_gen_manchester(&e, max - (e - events),
	346	&ir_rc6_timings[2], 1, 0);
	347	if (ret < 0)
	348	return ret;
	349
	350	/* Modulate rest of the data */
	351	ret = ir_raw_gen_manchester(&e, max - (e - events),
	352	&ir_rc6_timings[3], RC6_0_NBITS,
353	scancode);
354	if (ret < 0)
355	return ret;
356
357	} else {
358	int bits;
359
360	switch (protocol) {
361	case RC_TYPE_RC6_MCE:
362	case RC_TYPE_RC6_6A_32:
363	bits = 32;
364	break;
365	case RC_TYPE_RC6_6A_24:
366	bits = 24;
367	break;
368	case RC_TYPE_RC6_6A_20:
369	bits = 20;
370	break;
371	default:
372	return -EINVAL;
373	}
374
375	/* Modulate the preamble */
376	ret = ir_raw_gen_manchester(&e, max, &ir_rc6_timings[0], 0, 0);
377	if (ret < 0)
378	return ret;
379
380	/* Modulate the header (Start Bit & Header-version 6 */
381	ret = ir_raw_gen_manchester(&e, max - (e - events),
382	&ir_rc6_timings[1],
383	RC6_HEADER_NBITS, (1 << 3 \| 6));
384	if (ret < 0)
385	return ret;
386
387	/* Modulate Trailer Bit */
388	ret = ir_raw_gen_manchester(&e, max - (e - events),
389	&ir_rc6_timings[2], 1, 0);
390	if (ret < 0)
391	return ret;
392
393	/* Modulate rest of the data */
394	ret = ir_raw_gen_manchester(&e, max - (e - events),
395	&ir_rc6_timings[3],
396	bits,
397	scancode);
398	if (ret < 0)
399	return ret;
400	}
401
402	return e - events;
403	}
404
784a4931	405	static struct ir_raw_handler rc6_handler = {
c003ab1b DH	406	.protocols = RC_BIT_RC6_0 \| RC_BIT_RC6_6A_20 \|
	407	RC_BIT_RC6_6A_24 \| RC_BIT_RC6_6A_32 \|
	408	RC_BIT_RC6_MCE,
784a4931	409	.decode = ir_rc6_decode,
9d974e49	410	.encode = ir_rc6_encode,
784a4931 DH	411	};
	412
	413	static int __init ir_rc6_decode_init(void)
	414	{
	415	ir_raw_handler_register(&rc6_handler);
	416
	417	printk(KERN_INFO "IR RC6 protocol handler initialized\n");
	418	return 0;
	419	}
	420
	421	static void __exit ir_rc6_decode_exit(void)
	422	{
	423	ir_raw_handler_unregister(&rc6_handler);
	424	}
	425
	426	module_init(ir_rc6_decode_init);
	427	module_exit(ir_rc6_decode_exit);
	428
	429	MODULE_LICENSE("GPL");
	430	MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
	431	MODULE_DESCRIPTION("RC6 IR protocol decoder");