← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/media/rc/rc-core-priv.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/rc/rc-core-priv.h
 
1
/*
 
2
 * Remote Controller core raw events header
 
3
 *
 
4
 * Copyright (C) 2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
 
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
 
 
16
#ifndef _RC_CORE_PRIV
 
17
#define _RC_CORE_PRIV
 
18
 
 
19
#include <linux/slab.h>
 
20
#include <linux/spinlock.h>
 
21
#include <media/rc-core.h>
 
22
 
 
23
struct ir_raw_handler {
 
24
        struct list_head list;
 
25
 
 
26
        u64 protocols; /* which are handled by this handler */
 
27
        int (*decode)(struct rc_dev *dev, struct ir_raw_event event);
 
28
 
 
29
        /* These two should only be used by the lirc decoder */
 
30
        int (*raw_register)(struct rc_dev *dev);
 
31
        int (*raw_unregister)(struct rc_dev *dev);
 
32
};
 
33
 
 
34
struct ir_raw_event_ctrl {
 
35
        struct list_head                list;           /* to keep track of raw clients */
 
36
        struct task_struct              *thread;
 
37
        spinlock_t                      lock;
 
38
        struct kfifo                    kfifo;          /* fifo for the pulse/space durations */
 
39
        ktime_t                         last_event;     /* when last event occurred */
 
40
        enum raw_event_type             last_type;      /* last event type */
 
41
        struct rc_dev                   *dev;           /* pointer to the parent rc_dev */
 
42
        u64                             enabled_protocols; /* enabled raw protocol decoders */
 
43
 
 
44
        /* raw decoder state follows */
 
45
        struct ir_raw_event prev_ev;
 
46
        struct ir_raw_event this_ev;
 
47
        struct nec_dec {
 
48
                int state;
 
49
                unsigned count;
 
50
                u32 bits;
 
51
                bool is_nec_x;
 
52
                bool necx_repeat;
 
53
        } nec;
 
54
        struct rc5_dec {
 
55
                int state;
 
56
                u32 bits;
 
57
                unsigned count;
 
58
                unsigned wanted_bits;
 
59
        } rc5;
 
60
        struct rc6_dec {
 
61
                int state;
 
62
                u8 header;
 
63
                u32 body;
 
64
                bool toggle;
 
65
                unsigned count;
 
66
                unsigned wanted_bits;
 
67
        } rc6;
 
68
        struct sony_dec {
 
69
                int state;
 
70
                u32 bits;
 
71
                unsigned count;
 
72
        } sony;
 
73
        struct jvc_dec {
 
74
                int state;
 
75
                u16 bits;
 
76
                u16 old_bits;
 
77
                unsigned count;
 
78
                bool first;
 
79
                bool toggle;
 
80
        } jvc;
 
81
        struct rc5_sz_dec {
 
82
                int state;
 
83
                u32 bits;
 
84
                unsigned count;
 
85
                unsigned wanted_bits;
 
86
        } rc5_sz;
 
87
        struct mce_kbd_dec {
 
88
                struct input_dev *idev;
 
89
                struct timer_list rx_timeout;
 
90
                char name[64];
 
91
                char phys[64];
 
92
                int state;
 
93
                u8 header;
 
94
                u32 body;
 
95
                unsigned count;
 
96
                unsigned wanted_bits;
 
97
        } mce_kbd;
 
98
        struct lirc_codec {
 
99
                struct rc_dev *dev;
 
100
                struct lirc_driver *drv;
 
101
                int carrier_low;
 
102
 
 
103
                ktime_t gap_start;
 
104
                u64 gap_duration;
 
105
                bool gap;
 
106
                bool send_timeout_reports;
 
107
 
 
108
        } lirc;
 
109
};
 
110
 
 
111
/* macros for IR decoders */
 
112
static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
 
113
{
 
114
        return d1 > (d2 - margin);
 
115
}
 
116
 
 
117
static inline bool eq_margin(unsigned d1, unsigned d2, unsigned margin)
 
118
{
 
119
        return ((d1 > (d2 - margin)) && (d1 < (d2 + margin)));
 
120
}
 
121
 
 
122
static inline bool is_transition(struct ir_raw_event *x, struct ir_raw_event *y)
 
123
{
 
124
        return x->pulse != y->pulse;
 
125
}
 
126
 
 
127
static inline void decrease_duration(struct ir_raw_event *ev, unsigned duration)
 
128
{
 
129
        if (duration > ev->duration)
 
130
                ev->duration = 0;
 
131
        else
 
132
                ev->duration -= duration;
 
133
}
 
134
 
 
135
/* Returns true if event is normal pulse/space event */
 
136
static inline bool is_timing_event(struct ir_raw_event ev)
 
137
{
 
138
        return !ev.carrier_report && !ev.reset;
 
139
}
 
140
 
 
141
#define TO_US(duration)                 DIV_ROUND_CLOSEST((duration), 1000)
 
142
#define TO_STR(is_pulse)                ((is_pulse) ? "pulse" : "space")
 
143
 
 
144
/*
 
145
 * Routines from rc-raw.c to be used internally and by decoders
 
146
 */
 
147
u64 ir_raw_get_allowed_protocols(void);
 
148
int ir_raw_event_register(struct rc_dev *dev);
 
149
void ir_raw_event_unregister(struct rc_dev *dev);
 
150
int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler);
 
151
void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler);
 
152
void ir_raw_init(void);
 
153
 
 
154
/*
 
155
 * Decoder initialization code
 
156
 *
 
157
 * Those load logic are called during ir-core init, and automatically
 
158
 * loads the compiled decoders for their usage with IR raw events
 
159
 */
 
160
 
 
161
/* from ir-nec-decoder.c */
 
162
#ifdef CONFIG_IR_NEC_DECODER_MODULE
 
163
#define load_nec_decode()       request_module("ir-nec-decoder")
 
164
#else
 
165
static inline void load_nec_decode(void) { }
 
166
#endif
 
167
 
 
168
/* from ir-rc5-decoder.c */
 
169
#ifdef CONFIG_IR_RC5_DECODER_MODULE
 
170
#define load_rc5_decode()       request_module("ir-rc5-decoder")
 
171
#else
 
172
static inline void load_rc5_decode(void) { }
 
173
#endif
 
174
 
 
175
/* from ir-rc6-decoder.c */
 
176
#ifdef CONFIG_IR_RC6_DECODER_MODULE
 
177
#define load_rc6_decode()       request_module("ir-rc6-decoder")
 
178
#else
 
179
static inline void load_rc6_decode(void) { }
 
180
#endif
 
181
 
 
182
/* from ir-jvc-decoder.c */
 
183
#ifdef CONFIG_IR_JVC_DECODER_MODULE
 
184
#define load_jvc_decode()       request_module("ir-jvc-decoder")
 
185
#else
 
186
static inline void load_jvc_decode(void) { }
 
187
#endif
 
188
 
 
189
/* from ir-sony-decoder.c */
 
190
#ifdef CONFIG_IR_SONY_DECODER_MODULE
 
191
#define load_sony_decode()      request_module("ir-sony-decoder")
 
192
#else
 
193
static inline void load_sony_decode(void) { }
 
194
#endif
 
195
 
 
196
/* from ir-mce_kbd-decoder.c */
 
197
#ifdef CONFIG_IR_MCE_KBD_DECODER_MODULE
 
198
#define load_mce_kbd_decode()   request_module("ir-mce_kbd-decoder")
 
199
#else
 
200
static inline void load_mce_kbd_decode(void) { }
 
201
#endif
 
202
 
 
203
/* from ir-lirc-codec.c */
 
204
#ifdef CONFIG_IR_LIRC_CODEC_MODULE
 
205
#define load_lirc_codec()       request_module("ir-lirc-codec")
 
206
#else
 
207
static inline void load_lirc_codec(void) { }
 
208
#endif
 
209
 
 
210
 
 
211
#endif /* _RC_CORE_PRIV */