[linux-2.6-block.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 <linux/spinlock.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);

	/* 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;
	spinlock_t			lock;
	/* 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")

/*
 * 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>
c6ef1e7f	23	#include <linux/spinlock.h>
6bda9644	24	#include <media/rc-core.h>
3f113e36 MCC	25
	26	struct ir_raw_handler {
	27	struct list_head list;
	28
667c9ebe	29	u64 protocols; /* which are handled by this handler */
d8b4b582	30	int (decode)(struct rc_dev dev, struct ir_raw_event event);
c216369e DH	31
c216369e DH	32	/* These two should only be used by the lirc decoder */
d8b4b582 DH	33	int (raw_register)(struct rc_dev dev);
d8b4b582 DH	34	int (raw_unregister)(struct rc_dev dev);
3f113e36 MCC	35	};
	36
	37	struct ir_raw_event_ctrl {
c216369e	38	struct list_head list; /* to keep track of raw clients */
0d2cb1de	39	struct task_struct *thread;
c6ef1e7f	40	spinlock_t lock;
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 MCC	156
3f113e36 MCC	157	/*
d8b4b582	158	* Routines from rc-raw.c to be used internally and by decoders
3f113e36	159	*/
667c9ebe	160	u64 ir_raw_get_allowed_protocols(void);
d8b4b582 DH	161	int ir_raw_event_register(struct rc_dev *dev);
d8b4b582 DH	162	void ir_raw_event_unregister(struct rc_dev *dev);
3f113e36 MCC	163	int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
	164	void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
	165	void ir_raw_init(void);
	166
3f113e36 MCC	167	/*
	168	* Decoder initialization code
	169	*
	170	* Those load logic are called during ir-core init, and automatically
	171	* loads the compiled decoders for their usage with IR raw events
	172	*/
	173
829ba9fe	174	#endif /* _RC_CORE_PRIV */