Merge branch 'master'
[linux-2.6] / drivers / media / dvb / frontends / dvb_dummy_fe.c
1 /*
2  *  Driver for Dummy Frontend
3  *
4  *  Written by Emard <emard@softhome.net>
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; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.=
20  */
21
22 #include <linux/module.h>
23 #include <linux/moduleparam.h>
24 #include <linux/init.h>
25 #include <linux/string.h>
26 #include <linux/slab.h>
27
28 #include "dvb_frontend.h"
29 #include "dvb_dummy_fe.h"
30
31
32 struct dvb_dummy_fe_state {
33         struct dvb_frontend_ops ops;
34         struct dvb_frontend frontend;
35 };
36
37
38 static int dvb_dummy_fe_read_status(struct dvb_frontend* fe, fe_status_t* status)
39 {
40         *status = FE_HAS_SIGNAL
41                 | FE_HAS_CARRIER
42                 | FE_HAS_VITERBI
43                 | FE_HAS_SYNC
44                 | FE_HAS_LOCK;
45
46         return 0;
47 }
48
49 static int dvb_dummy_fe_read_ber(struct dvb_frontend* fe, u32* ber)
50 {
51         *ber = 0;
52         return 0;
53 }
54
55 static int dvb_dummy_fe_read_signal_strength(struct dvb_frontend* fe, u16* strength)
56 {
57         *strength = 0;
58         return 0;
59 }
60
61 static int dvb_dummy_fe_read_snr(struct dvb_frontend* fe, u16* snr)
62 {
63         *snr = 0;
64         return 0;
65 }
66
67 static int dvb_dummy_fe_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
68 {
69         *ucblocks = 0;
70         return 0;
71 }
72
73 static int dvb_dummy_fe_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
74 {
75         return 0;
76 }
77
78 static int dvb_dummy_fe_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
79 {
80         return 0;
81 }
82
83 static int dvb_dummy_fe_sleep(struct dvb_frontend* fe)
84 {
85         return 0;
86 }
87
88 static int dvb_dummy_fe_init(struct dvb_frontend* fe)
89 {
90         return 0;
91 }
92
93 static int dvb_dummy_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
94 {
95         return 0;
96 }
97
98 static int dvb_dummy_fe_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
99 {
100         return 0;
101 }
102
103 static void dvb_dummy_fe_release(struct dvb_frontend* fe)
104 {
105         struct dvb_dummy_fe_state* state = fe->demodulator_priv;
106         kfree(state);
107 }
108
109 static struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops;
110
111 struct dvb_frontend* dvb_dummy_fe_ofdm_attach(void)
112 {
113         struct dvb_dummy_fe_state* state = NULL;
114
115         /* allocate memory for the internal state */
116         state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
117         if (state == NULL) goto error;
118
119         /* setup the state */
120         memcpy(&state->ops, &dvb_dummy_fe_ofdm_ops, sizeof(struct dvb_frontend_ops));
121
122         /* create dvb_frontend */
123         state->frontend.ops = &state->ops;
124         state->frontend.demodulator_priv = state;
125         return &state->frontend;
126
127 error:
128         kfree(state);
129         return NULL;
130 }
131
132 static struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops;
133
134 struct dvb_frontend* dvb_dummy_fe_qpsk_attach()
135 {
136         struct dvb_dummy_fe_state* state = NULL;
137
138         /* allocate memory for the internal state */
139         state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
140         if (state == NULL) goto error;
141
142         /* setup the state */
143         memcpy(&state->ops, &dvb_dummy_fe_qpsk_ops, sizeof(struct dvb_frontend_ops));
144
145         /* create dvb_frontend */
146         state->frontend.ops = &state->ops;
147         state->frontend.demodulator_priv = state;
148         return &state->frontend;
149
150 error:
151         if (state) kfree(state);
152         return NULL;
153 }
154
155 static struct dvb_frontend_ops dvb_dummy_fe_qam_ops;
156
157 struct dvb_frontend* dvb_dummy_fe_qam_attach()
158 {
159         struct dvb_dummy_fe_state* state = NULL;
160
161         /* allocate memory for the internal state */
162         state = kmalloc(sizeof(struct dvb_dummy_fe_state), GFP_KERNEL);
163         if (state == NULL) goto error;
164
165         /* setup the state */
166         memcpy(&state->ops, &dvb_dummy_fe_qam_ops, sizeof(struct dvb_frontend_ops));
167
168         /* create dvb_frontend */
169         state->frontend.ops = &state->ops;
170         state->frontend.demodulator_priv = state;
171         return &state->frontend;
172
173 error:
174         if (state) kfree(state);
175         return NULL;
176 }
177
178 static struct dvb_frontend_ops dvb_dummy_fe_ofdm_ops = {
179
180         .info = {
181                 .name                   = "Dummy DVB-T",
182                 .type                   = FE_OFDM,
183                 .frequency_min          = 0,
184                 .frequency_max          = 863250000,
185                 .frequency_stepsize     = 62500,
186                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
187                                 FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
188                                 FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
189                                 FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
190                                 FE_CAN_TRANSMISSION_MODE_AUTO |
191                                 FE_CAN_GUARD_INTERVAL_AUTO |
192                                 FE_CAN_HIERARCHY_AUTO,
193         },
194
195         .release = dvb_dummy_fe_release,
196
197         .init = dvb_dummy_fe_init,
198         .sleep = dvb_dummy_fe_sleep,
199
200         .set_frontend = dvb_dummy_fe_set_frontend,
201         .get_frontend = dvb_dummy_fe_get_frontend,
202
203         .read_status = dvb_dummy_fe_read_status,
204         .read_ber = dvb_dummy_fe_read_ber,
205         .read_signal_strength = dvb_dummy_fe_read_signal_strength,
206         .read_snr = dvb_dummy_fe_read_snr,
207         .read_ucblocks = dvb_dummy_fe_read_ucblocks,
208 };
209
210 static struct dvb_frontend_ops dvb_dummy_fe_qam_ops = {
211
212         .info = {
213                 .name                   = "Dummy DVB-C",
214                 .type                   = FE_QAM,
215                 .frequency_stepsize     = 62500,
216                 .frequency_min          = 51000000,
217                 .frequency_max          = 858000000,
218                 .symbol_rate_min        = (57840000/2)/64,     /* SACLK/64 == (XIN/2)/64 */
219                 .symbol_rate_max        = (57840000/2)/4,      /* SACLK/4 */
220                 .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
221                         FE_CAN_QAM_128 | FE_CAN_QAM_256 |
222                         FE_CAN_FEC_AUTO | FE_CAN_INVERSION_AUTO
223         },
224
225         .release = dvb_dummy_fe_release,
226
227         .init = dvb_dummy_fe_init,
228         .sleep = dvb_dummy_fe_sleep,
229
230         .set_frontend = dvb_dummy_fe_set_frontend,
231         .get_frontend = dvb_dummy_fe_get_frontend,
232
233         .read_status = dvb_dummy_fe_read_status,
234         .read_ber = dvb_dummy_fe_read_ber,
235         .read_signal_strength = dvb_dummy_fe_read_signal_strength,
236         .read_snr = dvb_dummy_fe_read_snr,
237         .read_ucblocks = dvb_dummy_fe_read_ucblocks,
238 };
239
240 static struct dvb_frontend_ops dvb_dummy_fe_qpsk_ops = {
241
242         .info = {
243                 .name                   = "Dummy DVB-S",
244                 .type                   = FE_QPSK,
245                 .frequency_min          = 950000,
246                 .frequency_max          = 2150000,
247                 .frequency_stepsize     = 250,           /* kHz for QPSK frontends */
248                 .frequency_tolerance    = 29500,
249                 .symbol_rate_min        = 1000000,
250                 .symbol_rate_max        = 45000000,
251                 .caps = FE_CAN_INVERSION_AUTO |
252                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
253                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
254                         FE_CAN_QPSK
255         },
256
257         .release = dvb_dummy_fe_release,
258
259         .init = dvb_dummy_fe_init,
260         .sleep = dvb_dummy_fe_sleep,
261
262         .set_frontend = dvb_dummy_fe_set_frontend,
263         .get_frontend = dvb_dummy_fe_get_frontend,
264
265         .read_status = dvb_dummy_fe_read_status,
266         .read_ber = dvb_dummy_fe_read_ber,
267         .read_signal_strength = dvb_dummy_fe_read_signal_strength,
268         .read_snr = dvb_dummy_fe_read_snr,
269         .read_ucblocks = dvb_dummy_fe_read_ucblocks,
270
271         .set_voltage = dvb_dummy_fe_set_voltage,
272         .set_tone = dvb_dummy_fe_set_tone,
273 };
274
275 MODULE_DESCRIPTION("DVB DUMMY Frontend");
276 MODULE_AUTHOR("Emard");
277 MODULE_LICENSE("GPL");
278
279 EXPORT_SYMBOL(dvb_dummy_fe_ofdm_attach);
280 EXPORT_SYMBOL(dvb_dummy_fe_qam_attach);
281 EXPORT_SYMBOL(dvb_dummy_fe_qpsk_attach);