[mirror_ubuntu-artful-kernel.git] / drivers / media / rc / rc-core-priv.h

/*
 * Remote Controller core raw events header
 *
 * Copyright (C) 2010 by Mauro Carvalho Chehab
 *
 * 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.
 */

#ifndef _RC_CORE_PRIV
#define _RC_CORE_PRIV

/* Define the max number of pulse/space transitions to buffer */
#define	MAX_IR_EVENT_SIZE	512

#include <linux/slab.h>
#include <media/rc-core.h>

struct ir_raw_handler {
	struct list_head list;

	u64 protocols; /* which are handled by this handler */
	int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
	int (*encode)(enum rc_type protocol, u32 scancode,
		      struct ir_raw_event *events, unsigned int max);

	/* These two should only be used by the lirc decoder */
	int (*raw_register)(struct rc_dev *dev);
	int (*raw_unregister)(struct rc_dev *dev);
};

struct ir_raw_event_ctrl {
	struct list_head		list;		/* to keep track of raw clients */
	struct task_struct		*thread;
	/* fifo for the pulse/space durations */
	DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE);
	ktime_t				last_event;	/* when last event occurred */
	enum raw_event_type		last_type;	/* last event type */
	struct rc_dev			*dev;		/* pointer to the parent rc_dev */

	/* raw decoder state follows */
	struct ir_raw_event prev_ev;
	struct ir_raw_event this_ev;
	struct nec_dec {
		int state;
		unsigned count;
		u32 bits;
		bool is_nec_x;
		bool necx_repeat;
	} nec;
	struct rc5_dec {
		int state;
		u32 bits;
		unsigned count;
		bool is_rc5x;
	} rc5;
	struct rc6_dec {
		int state;
		u8 header;
		u32 body;
		bool toggle;
		unsigned count;
		unsigned wanted_bits;
	} rc6;
	struct sony_dec {
		int state;
		u32 bits;
		unsigned count;
	} sony;
	struct jvc_dec {
		int state;
		u16 bits;
		u16 old_bits;
		unsigned count;
		bool first;
		bool toggle;
	} jvc;
	struct sanyo_dec {
		int state;
		unsigned count;
		u64 bits;
	} sanyo;
	struct sharp_dec {
		int state;
		unsigned count;
		u32 bits;
		unsigned int pulse_len;
	} sharp;
	struct mce_kbd_dec {
		struct input_dev *idev;
		struct timer_list rx_timeout;
		char name[64];
		char phys[64];
		int state;
		u8 header;
		u32 body;
		unsigned count;
		unsigned wanted_bits;
	} mce_kbd;
	struct lirc_codec {
		struct rc_dev *dev;
		struct lirc_driver *drv;
		int carrier_low;

		ktime_t gap_start;
		u64 gap_duration;
		bool gap;
		bool send_timeout_reports;

	} lirc;
	struct xmp_dec {
		int state;
		unsigned count;
		u32 durations[16];
	} xmp;
};

/* macros for IR decoders */
static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
{
	return d1 > (d2 - margin);
}

static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
{
	return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
}

static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
{
	return x->pulse != y->pulse;
}

static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
{
	if (duration > ev->duration)
		ev->duration = 0;
	else
		ev->duration -= duration;
}

/* Returns true if event is normal pulse/space event */
static inline bool is_timing_event(struct ir_raw_event ev)
{
	return !ev.carrier_report && !ev.reset;
}

#define TO_US(duration)			DIV_ROUND_CLOSEST((duration), 1000)
#define TO_STR(is_pulse)		((is_pulse) ? "pulse" : "space")

/* functions for IR encoders */

static inline void init_ir_raw_event_duration(struct ir_raw_event *ev,
					      unsigned int pulse,
					      u32 duration)
{
	init_ir_raw_event(ev);
	ev->duration = duration;
	ev->pulse = pulse;
}

/**
 * struct ir_raw_timings_manchester - Manchester coding timings
 * @leader:		duration of leader pulse (if any) 0 if continuing
 *			existing signal (see @pulse_space_start)
 * @pulse_space_start:	1 for starting with pulse (0 for starting with space)
 * @clock:		duration of each pulse/space in ns
 * @invert:		if set clock logic is inverted
 *			(0 = space + pulse, 1 = pulse + space)
 * @trailer_space:	duration of trailer space in ns
 */
struct ir_raw_timings_manchester {
	unsigned int leader;
	unsigned int pulse_space_start:1;
	unsigned int clock;
	unsigned int invert:1;
	unsigned int trailer_space;
};

int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
			  const struct ir_raw_timings_manchester *timings,
			  unsigned int n, unsigned int data);

/**
 * ir_raw_gen_pulse_space() - generate pulse and space raw events.
 * @ev:			Pointer to pointer to next free raw event.
 *			Will be incremented for each raw event written.
 * @max:		Pointer to number of raw events available in buffer.
 *			Will be decremented for each raw event written.
 * @pulse_width:	Width of pulse in ns.
 * @space_width:	Width of space in ns.
 *
 * Returns:	0 on success.
 *		-ENOBUFS if there isn't enough buffer space to write both raw
 *		events. In this case @max events will have been written.
 */
static inline int ir_raw_gen_pulse_space(struct ir_raw_event **ev,
					 unsigned int *max,
					 unsigned int pulse_width,
					 unsigned int space_width)
{
	if (!*max)
		return -ENOBUFS;
	init_ir_raw_event_duration((*ev)++, 1, pulse_width);
	if (!--*max)
		return -ENOBUFS;
	init_ir_raw_event_duration((*ev)++, 0, space_width);
	--*max;
	return 0;
}

/**
 * struct ir_raw_timings_pd - pulse-distance modulation timings
 * @header_pulse:	duration of header pulse in ns (0 for none)
 * @header_space:	duration of header space in ns
 * @bit_pulse:		duration of bit pulse in ns
 * @bit_space:		duration of bit space (for logic 0 and 1) in ns
 * @trailer_pulse:	duration of trailer pulse in ns
 * @trailer_space:	duration of trailer space in ns
 * @msb_first:		1 if most significant bit is sent first
 */
struct ir_raw_timings_pd {
	unsigned int header_pulse;
	unsigned int header_space;
	unsigned int bit_pulse;
	unsigned int bit_space[2];
	unsigned int trailer_pulse;
	unsigned int trailer_space;
	unsigned int msb_first:1;
};

int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max,
		  const struct ir_raw_timings_pd *timings,
		  unsigned int n, u64 data);

/**
 * struct ir_raw_timings_pl - pulse-length modulation timings
 * @header_pulse:	duration of header pulse in ns (0 for none)
 * @bit_space:		duration of bit space in ns
 * @bit_pulse:		duration of bit pulse (for logic 0 and 1) in ns
 * @trailer_space:	duration of trailer space in ns
 * @msb_first:		1 if most significant bit is sent first
 */
struct ir_raw_timings_pl {
	unsigned int header_pulse;
	unsigned int bit_space;
	unsigned int bit_pulse[2];
	unsigned int trailer_space;
	unsigned int msb_first:1;
};

int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max,
		  const struct ir_raw_timings_pl *timings,
		  unsigned int n, u64 data);

/*
 * Routines from rc-raw.c to be used internally and by decoders
 */
u64 ir_raw_get_allowed_protocols(void);
int ir_raw_event_register(struct rc_dev *dev);
void ir_raw_event_unregister(struct rc_dev *dev);
int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
void ir_raw_init(void);

/*
 * Decoder initialization code
 *
 * Those load logic are called during ir-core init, and automatically
 * loads the compiled decoders for their usage with IR raw events
 */

#endif /* _RC_CORE_PRIV */
Commit	Line	Data
3f113e36 MCC	1	/*
	2	* Remote Controller core raw events header
	3	*
37e59f87	4	* Copyright (C) 2010 by Mauro Carvalho Chehab
3f113e36 MCC	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation version 2 of the License.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15
829ba9fe DH	16	#ifndef _RC_CORE_PRIV
829ba9fe DH	17	#define _RC_CORE_PRIV
3f113e36	18
464254e5 HK	19	/* Define the max number of pulse/space transitions to buffer */
	20	#define MAX_IR_EVENT_SIZE 512
	21
3f113e36	22	#include <linux/slab.h>
6bda9644	23	#include <media/rc-core.h>
3f113e36 MCC	24
	25	struct ir_raw_handler {
	26	struct list_head list;
	27
667c9ebe	28	u64 protocols; /* which are handled by this handler */
d8b4b582	29	int (decode)(struct rc_dev dev, struct ir_raw_event event);
3875233d JH	30	int (*encode)(enum rc_type protocol, u32 scancode,
3875233d JH	31	struct ir_raw_event *events, unsigned int max);
c216369e DH	32
c216369e DH	33	/* These two should only be used by the lirc decoder */
d8b4b582 DH	34	int (raw_register)(struct rc_dev dev);
d8b4b582 DH	35	int (raw_unregister)(struct rc_dev dev);
3f113e36 MCC	36	};
	37
	38	struct ir_raw_event_ctrl {
c216369e	39	struct list_head list; /* to keep track of raw clients */
0d2cb1de	40	struct task_struct *thread;
464254e5 HK	41	/* fifo for the pulse/space durations */
464254e5 HK	42	DECLARE_KFIFO(kfifo, struct ir_raw_event, MAX_IR_EVENT_SIZE);
3f113e36 MCC	43	ktime_t last_event; /* when last event occurred */
3f113e36 MCC	44	enum raw_event_type last_type; /* last event type */
d8b4b582	45	struct rc_dev dev; / pointer to the parent rc_dev */
c216369e DH	46
	47	/* raw decoder state follows */
	48	struct ir_raw_event prev_ev;
4a702ebf	49	struct ir_raw_event this_ev;
c216369e DH	50	struct nec_dec {
	51	int state;
	52	unsigned count;
	53	u32 bits;
86ff071c ML	54	bool is_nec_x;
86ff071c ML	55	bool necx_repeat;
c216369e DH	56	} nec;
	57	struct rc5_dec {
	58	int state;
	59	u32 bits;
	60	unsigned count;
e87b540b	61	bool is_rc5x;
c216369e DH	62	} rc5;
	63	struct rc6_dec {
	64	int state;
	65	u8 header;
	66	u32 body;
	67	bool toggle;
	68	unsigned count;
	69	unsigned wanted_bits;
	70	} rc6;
	71	struct sony_dec {
	72	int state;
	73	u32 bits;
	74	unsigned count;
	75	} sony;
	76	struct jvc_dec {
	77	int state;
	78	u16 bits;
	79	u16 old_bits;
	80	unsigned count;
	81	bool first;
	82	bool toggle;
	83	} jvc;
b32e7243 MCC	84	struct sanyo_dec {
	85	int state;
	86	unsigned count;
	87	u64 bits;
	88	} sanyo;
1d184b0b JH	89	struct sharp_dec {
	90	int state;
	91	unsigned count;
	92	u32 bits;
	93	unsigned int pulse_len;
	94	} sharp;
f5f2cc64 JW	95	struct mce_kbd_dec {
	96	struct input_dev *idev;
	97	struct timer_list rx_timeout;
	98	char name[64];
	99	char phys[64];
	100	int state;
	101	u8 header;
	102	u32 body;
	103	unsigned count;
	104	unsigned wanted_bits;
	105	} mce_kbd;
ca414698	106	struct lirc_codec {
d8b4b582	107	struct rc_dev *dev;
ca414698	108	struct lirc_driver *drv;
e589333f	109	int carrier_low;
4651918a ML	110
	111	ktime_t gap_start;
	112	u64 gap_duration;
	113	bool gap;
	114	bool send_timeout_reports;
	115
ca414698	116	} lirc;
1dee9b59 MM	117	struct xmp_dec {
	118	int state;
	119	unsigned count;
	120	u32 durations[16];
	121	} xmp;
3f113e36 MCC	122	};
	123
	124	/* macros for IR decoders */
384f23e8 MCC	125	static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
384f23e8 MCC	126	{
e40b1127 DH	127	return d1 > (d2 - margin);
	128	}
	129
384f23e8 MCC	130	static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
384f23e8 MCC	131	{
e40b1127 DH	132	return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
	133	}
	134
384f23e8 MCC	135	static inline bool is_transition(struct ir_raw_event x, struct ir_raw_event y)
384f23e8 MCC	136	{
e40b1127 DH	137	return x->pulse != y->pulse;
	138	}
	139
384f23e8 MCC	140	static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
384f23e8 MCC	141	{
e40b1127 DH	142	if (duration > ev->duration)
	143	ev->duration = 0;
	144	else
	145	ev->duration -= duration;
	146	}
	147
4651918a ML	148	/* Returns true if event is normal pulse/space event */
	149	static inline bool is_timing_event(struct ir_raw_event ev)
	150	{
	151	return !ev.carrier_report && !ev.reset;
	152	}
	153
510fcb70	154	#define TO_US(duration) DIV_ROUND_CLOSEST((duration), 1000)
e40b1127	155	#define TO_STR(is_pulse) ((is_pulse) ? "pulse" : "space")
3f113e36	156
844a4f45 AS	157	/* functions for IR encoders */
	158
	159	static inline void init_ir_raw_event_duration(struct ir_raw_event *ev,
	160	unsigned int pulse,
	161	u32 duration)
	162	{
	163	init_ir_raw_event(ev);
	164	ev->duration = duration;
	165	ev->pulse = pulse;
	166	}
	167
	168	/**
	169	* struct ir_raw_timings_manchester - Manchester coding timings
	170	* @leader: duration of leader pulse (if any) 0 if continuing
	171	* existing signal (see @pulse_space_start)
	172	* @pulse_space_start: 1 for starting with pulse (0 for starting with space)
	173	* @clock: duration of each pulse/space in ns
	174	* @invert: if set clock logic is inverted
	175	* (0 = space + pulse, 1 = pulse + space)
	176	* @trailer_space: duration of trailer space in ns
	177	*/
	178	struct ir_raw_timings_manchester {
	179	unsigned int leader;
	180	unsigned int pulse_space_start:1;
	181	unsigned int clock;
	182	unsigned int invert:1;
	183	unsigned int trailer_space;
	184	};
	185
	186	int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
	187	const struct ir_raw_timings_manchester *timings,
	188	unsigned int n, unsigned int data);
	189
caec0984 JH	190	/**
	191	* ir_raw_gen_pulse_space() - generate pulse and space raw events.
	192	* @ev: Pointer to pointer to next free raw event.
	193	* Will be incremented for each raw event written.
	194	* @max: Pointer to number of raw events available in buffer.
	195	* Will be decremented for each raw event written.
	196	* @pulse_width: Width of pulse in ns.
	197	* @space_width: Width of space in ns.
	198	*
	199	* Returns: 0 on success.
	200	* -ENOBUFS if there isn't enough buffer space to write both raw
	201	* events. In this case @max events will have been written.
	202	*/
	203	static inline int ir_raw_gen_pulse_space(struct ir_raw_event **ev,
	204	unsigned int *max,
	205	unsigned int pulse_width,
	206	unsigned int space_width)
	207	{
	208	if (!*max)
	209	return -ENOBUFS;
	210	init_ir_raw_event_duration((*ev)++, 1, pulse_width);
	211	if (!--*max)
	212	return -ENOBUFS;
	213	init_ir_raw_event_duration((*ev)++, 0, space_width);
	214	--*max;
	215	return 0;
	216	}
	217
	218	/**
	219	* struct ir_raw_timings_pd - pulse-distance modulation timings
	220	* @header_pulse: duration of header pulse in ns (0 for none)
	221	* @header_space: duration of header space in ns
	222	* @bit_pulse: duration of bit pulse in ns
	223	* @bit_space: duration of bit space (for logic 0 and 1) in ns
	224	* @trailer_pulse: duration of trailer pulse in ns
	225	* @trailer_space: duration of trailer space in ns
	226	* @msb_first: 1 if most significant bit is sent first
	227	*/
	228	struct ir_raw_timings_pd {
	229	unsigned int header_pulse;
	230	unsigned int header_space;
	231	unsigned int bit_pulse;
	232	unsigned int bit_space[2];
	233	unsigned int trailer_pulse;
	234	unsigned int trailer_space;
	235	unsigned int msb_first:1;
	236	};
	237
	238	int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max,
	239	const struct ir_raw_timings_pd *timings,
	240	unsigned int n, u64 data);
	241
103293be SY	242	/**
	243	* struct ir_raw_timings_pl - pulse-length modulation timings
	244	* @header_pulse: duration of header pulse in ns (0 for none)
	245	* @bit_space: duration of bit space in ns
	246	* @bit_pulse: duration of bit pulse (for logic 0 and 1) in ns
	247	* @trailer_space: duration of trailer space in ns
	248	* @msb_first: 1 if most significant bit is sent first
	249	*/
	250	struct ir_raw_timings_pl {
	251	unsigned int header_pulse;
	252	unsigned int bit_space;
	253	unsigned int bit_pulse[2];
	254	unsigned int trailer_space;
	255	unsigned int msb_first:1;
	256	};
	257
	258	int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max,
	259	const struct ir_raw_timings_pl *timings,
	260	unsigned int n, u64 data);
	261
3f113e36	262	/*
d8b4b582	263	* Routines from rc-raw.c to be used internally and by decoders
3f113e36	264	*/
667c9ebe	265	u64 ir_raw_get_allowed_protocols(void);
d8b4b582 DH	266	int ir_raw_event_register(struct rc_dev *dev);
d8b4b582 DH	267	void ir_raw_event_unregister(struct rc_dev *dev);
3f113e36 MCC	268	int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
	269	void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
	270	void ir_raw_init(void);
	271
3f113e36 MCC	272	/*
	273	* Decoder initialization code
	274	*
	275	* Those load logic are called during ir-core init, and automatically
	276	* loads the compiled decoders for their usage with IR raw events
	277	*/
	278
829ba9fe	279	#endif /* _RC_CORE_PRIV */