diff options
Diffstat (limited to 'drivers/media/dvb/frontends/stv0288.c')
-rw-r--r-- | drivers/media/dvb/frontends/stv0288.c | 606 |
1 files changed, 606 insertions, 0 deletions
diff --git a/drivers/media/dvb/frontends/stv0288.c b/drivers/media/dvb/frontends/stv0288.c new file mode 100644 index 000000000000..90e72e771a04 --- /dev/null +++ b/drivers/media/dvb/frontends/stv0288.c | |||
@@ -0,0 +1,606 @@ | |||
1 | /* | ||
2 | Driver for ST STV0288 demodulator | ||
3 | Copyright (C) 2006 Georg Acher, BayCom GmbH, acher (at) baycom (dot) de | ||
4 | for Reel Multimedia | ||
5 | Copyright (C) 2008 TurboSight.com, Bob Liu <bob@turbosight.com> | ||
6 | Copyright (C) 2008 Igor M. Liplianin <liplianin@me.by> | ||
7 | Removed stb6000 specific tuner code and revised some | ||
8 | procedures. | ||
9 | |||
10 | This program is free software; you can redistribute it and/or modify | ||
11 | it under the terms of the GNU General Public License as published by | ||
12 | the Free Software Foundation; either version 2 of the License, or | ||
13 | (at your option) any later version. | ||
14 | |||
15 | This program is distributed in the hope that it will be useful, | ||
16 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | GNU General Public License for more details. | ||
19 | |||
20 | You should have received a copy of the GNU General Public License | ||
21 | along with this program; if not, write to the Free Software | ||
22 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
23 | |||
24 | */ | ||
25 | |||
26 | #include <linux/init.h> | ||
27 | #include <linux/kernel.h> | ||
28 | #include <linux/module.h> | ||
29 | #include <linux/string.h> | ||
30 | #include <linux/slab.h> | ||
31 | #include <linux/jiffies.h> | ||
32 | #include <asm/div64.h> | ||
33 | |||
34 | #include "dvb_frontend.h" | ||
35 | #include "stv0288.h" | ||
36 | |||
37 | struct stv0288_state { | ||
38 | struct i2c_adapter *i2c; | ||
39 | const struct stv0288_config *config; | ||
40 | struct dvb_frontend frontend; | ||
41 | |||
42 | u8 initialised:1; | ||
43 | u32 tuner_frequency; | ||
44 | u32 symbol_rate; | ||
45 | fe_code_rate_t fec_inner; | ||
46 | int errmode; | ||
47 | }; | ||
48 | |||
49 | #define STATUS_BER 0 | ||
50 | #define STATUS_UCBLOCKS 1 | ||
51 | |||
52 | static int debug; | ||
53 | static int debug_legacy_dish_switch; | ||
54 | #define dprintk(args...) \ | ||
55 | do { \ | ||
56 | if (debug) \ | ||
57 | printk(KERN_DEBUG "stv0288: " args); \ | ||
58 | } while (0) | ||
59 | |||
60 | |||
61 | static int stv0288_writeregI(struct stv0288_state *state, u8 reg, u8 data) | ||
62 | { | ||
63 | int ret; | ||
64 | u8 buf[] = { reg, data }; | ||
65 | struct i2c_msg msg = { | ||
66 | .addr = state->config->demod_address, | ||
67 | .flags = 0, | ||
68 | .buf = buf, | ||
69 | .len = 2 | ||
70 | }; | ||
71 | |||
72 | ret = i2c_transfer(state->i2c, &msg, 1); | ||
73 | |||
74 | if (ret != 1) | ||
75 | dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, " | ||
76 | "ret == %i)\n", __func__, reg, data, ret); | ||
77 | |||
78 | return (ret != 1) ? -EREMOTEIO : 0; | ||
79 | } | ||
80 | |||
81 | static int stv0288_write(struct dvb_frontend *fe, u8 *buf, int len) | ||
82 | { | ||
83 | struct stv0288_state *state = fe->demodulator_priv; | ||
84 | |||
85 | if (len != 2) | ||
86 | return -EINVAL; | ||
87 | |||
88 | return stv0288_writeregI(state, buf[0], buf[1]); | ||
89 | } | ||
90 | |||
91 | static u8 stv0288_readreg(struct stv0288_state *state, u8 reg) | ||
92 | { | ||
93 | int ret; | ||
94 | u8 b0[] = { reg }; | ||
95 | u8 b1[] = { 0 }; | ||
96 | struct i2c_msg msg[] = { | ||
97 | { | ||
98 | .addr = state->config->demod_address, | ||
99 | .flags = 0, | ||
100 | .buf = b0, | ||
101 | .len = 1 | ||
102 | }, { | ||
103 | .addr = state->config->demod_address, | ||
104 | .flags = I2C_M_RD, | ||
105 | .buf = b1, | ||
106 | .len = 1 | ||
107 | } | ||
108 | }; | ||
109 | |||
110 | ret = i2c_transfer(state->i2c, msg, 2); | ||
111 | |||
112 | if (ret != 2) | ||
113 | dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", | ||
114 | __func__, reg, ret); | ||
115 | |||
116 | return b1[0]; | ||
117 | } | ||
118 | |||
119 | static int stv0288_set_symbolrate(struct dvb_frontend *fe, u32 srate) | ||
120 | { | ||
121 | struct stv0288_state *state = fe->demodulator_priv; | ||
122 | unsigned int temp; | ||
123 | unsigned char b[3]; | ||
124 | |||
125 | if ((srate < 1000000) || (srate > 45000000)) | ||
126 | return -EINVAL; | ||
127 | |||
128 | temp = (unsigned int)srate / 1000; | ||
129 | |||
130 | temp = temp * 32768; | ||
131 | temp = temp / 25; | ||
132 | temp = temp / 125; | ||
133 | b[0] = (unsigned char)((temp >> 12) & 0xff); | ||
134 | b[1] = (unsigned char)((temp >> 4) & 0xff); | ||
135 | b[2] = (unsigned char)((temp << 4) & 0xf0); | ||
136 | stv0288_writeregI(state, 0x28, 0x80); /* SFRH */ | ||
137 | stv0288_writeregI(state, 0x29, 0); /* SFRM */ | ||
138 | stv0288_writeregI(state, 0x2a, 0); /* SFRL */ | ||
139 | |||
140 | stv0288_writeregI(state, 0x28, b[0]); | ||
141 | stv0288_writeregI(state, 0x29, b[1]); | ||
142 | stv0288_writeregI(state, 0x2a, b[2]); | ||
143 | dprintk("stv0288: stv0288_set_symbolrate\n"); | ||
144 | |||
145 | return 0; | ||
146 | } | ||
147 | |||
148 | static int stv0288_send_diseqc_msg(struct dvb_frontend *fe, | ||
149 | struct dvb_diseqc_master_cmd *m) | ||
150 | { | ||
151 | struct stv0288_state *state = fe->demodulator_priv; | ||
152 | |||
153 | int i; | ||
154 | |||
155 | dprintk("%s\n", __func__); | ||
156 | |||
157 | stv0288_writeregI(state, 0x09, 0); | ||
158 | msleep(30); | ||
159 | stv0288_writeregI(state, 0x05, 0x16); | ||
160 | |||
161 | for (i = 0; i < m->msg_len; i++) { | ||
162 | if (stv0288_writeregI(state, 0x06, m->msg[i])) | ||
163 | return -EREMOTEIO; | ||
164 | msleep(12); | ||
165 | } | ||
166 | |||
167 | return 0; | ||
168 | } | ||
169 | |||
170 | static int stv0288_send_diseqc_burst(struct dvb_frontend *fe, | ||
171 | fe_sec_mini_cmd_t burst) | ||
172 | { | ||
173 | struct stv0288_state *state = fe->demodulator_priv; | ||
174 | |||
175 | dprintk("%s\n", __func__); | ||
176 | |||
177 | if (stv0288_writeregI(state, 0x05, 0x16))/* burst mode */ | ||
178 | return -EREMOTEIO; | ||
179 | |||
180 | if (stv0288_writeregI(state, 0x06, burst == SEC_MINI_A ? 0x00 : 0xff)) | ||
181 | return -EREMOTEIO; | ||
182 | |||
183 | if (stv0288_writeregI(state, 0x06, 0x12)) | ||
184 | return -EREMOTEIO; | ||
185 | |||
186 | return 0; | ||
187 | } | ||
188 | |||
189 | static int stv0288_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone) | ||
190 | { | ||
191 | struct stv0288_state *state = fe->demodulator_priv; | ||
192 | |||
193 | switch (tone) { | ||
194 | case SEC_TONE_ON: | ||
195 | if (stv0288_writeregI(state, 0x05, 0x10))/* burst mode */ | ||
196 | return -EREMOTEIO; | ||
197 | return stv0288_writeregI(state, 0x06, 0xff); | ||
198 | |||
199 | case SEC_TONE_OFF: | ||
200 | if (stv0288_writeregI(state, 0x05, 0x13))/* burst mode */ | ||
201 | return -EREMOTEIO; | ||
202 | return stv0288_writeregI(state, 0x06, 0x00); | ||
203 | |||
204 | default: | ||
205 | return -EINVAL; | ||
206 | } | ||
207 | } | ||
208 | |||
209 | static u8 stv0288_inittab[] = { | ||
210 | 0x01, 0x15, | ||
211 | 0x02, 0x20, | ||
212 | 0x09, 0x0, | ||
213 | 0x0a, 0x4, | ||
214 | 0x0b, 0x0, | ||
215 | 0x0c, 0x0, | ||
216 | 0x0d, 0x0, | ||
217 | 0x0e, 0xd4, | ||
218 | 0x0f, 0x30, | ||
219 | 0x11, 0x80, | ||
220 | 0x12, 0x03, | ||
221 | 0x13, 0x48, | ||
222 | 0x14, 0x84, | ||
223 | 0x15, 0x45, | ||
224 | 0x16, 0xb7, | ||
225 | 0x17, 0x9c, | ||
226 | 0x18, 0x0, | ||
227 | 0x19, 0xa6, | ||
228 | 0x1a, 0x88, | ||
229 | 0x1b, 0x8f, | ||
230 | 0x1c, 0xf0, | ||
231 | 0x20, 0x0b, | ||
232 | 0x21, 0x54, | ||
233 | 0x22, 0x0, | ||
234 | 0x23, 0x0, | ||
235 | 0x2b, 0xff, | ||
236 | 0x2c, 0xf7, | ||
237 | 0x30, 0x0, | ||
238 | 0x31, 0x1e, | ||
239 | 0x32, 0x14, | ||
240 | 0x33, 0x0f, | ||
241 | 0x34, 0x09, | ||
242 | 0x35, 0x0c, | ||
243 | 0x36, 0x05, | ||
244 | 0x37, 0x2f, | ||
245 | 0x38, 0x16, | ||
246 | 0x39, 0xbe, | ||
247 | 0x3a, 0x0, | ||
248 | 0x3b, 0x13, | ||
249 | 0x3c, 0x11, | ||
250 | 0x3d, 0x30, | ||
251 | 0x40, 0x63, | ||
252 | 0x41, 0x04, | ||
253 | 0x42, 0x60, | ||
254 | 0x43, 0x00, | ||
255 | 0x44, 0x00, | ||
256 | 0x45, 0x00, | ||
257 | 0x46, 0x00, | ||
258 | 0x47, 0x00, | ||
259 | 0x4a, 0x00, | ||
260 | 0x50, 0x10, | ||
261 | 0x51, 0x38, | ||
262 | 0x52, 0x21, | ||
263 | 0x58, 0x54, | ||
264 | 0x59, 0x86, | ||
265 | 0x5a, 0x0, | ||
266 | 0x5b, 0x9b, | ||
267 | 0x5c, 0x08, | ||
268 | 0x5d, 0x7f, | ||
269 | 0x5e, 0x0, | ||
270 | 0x5f, 0xff, | ||
271 | 0x70, 0x0, | ||
272 | 0x71, 0x0, | ||
273 | 0x72, 0x0, | ||
274 | 0x74, 0x0, | ||
275 | 0x75, 0x0, | ||
276 | 0x76, 0x0, | ||
277 | 0x81, 0x0, | ||
278 | 0x82, 0x3f, | ||
279 | 0x83, 0x3f, | ||
280 | 0x84, 0x0, | ||
281 | 0x85, 0x0, | ||
282 | 0x88, 0x0, | ||
283 | 0x89, 0x0, | ||
284 | 0x8a, 0x0, | ||
285 | 0x8b, 0x0, | ||
286 | 0x8c, 0x0, | ||
287 | 0x90, 0x0, | ||
288 | 0x91, 0x0, | ||
289 | 0x92, 0x0, | ||
290 | 0x93, 0x0, | ||
291 | 0x94, 0x1c, | ||
292 | 0x97, 0x0, | ||
293 | 0xa0, 0x48, | ||
294 | 0xa1, 0x0, | ||
295 | 0xb0, 0xb8, | ||
296 | 0xb1, 0x3a, | ||
297 | 0xb2, 0x10, | ||
298 | 0xb3, 0x82, | ||
299 | 0xb4, 0x80, | ||
300 | 0xb5, 0x82, | ||
301 | 0xb6, 0x82, | ||
302 | 0xb7, 0x82, | ||
303 | 0xb8, 0x20, | ||
304 | 0xb9, 0x0, | ||
305 | 0xf0, 0x0, | ||
306 | 0xf1, 0x0, | ||
307 | 0xf2, 0xc0, | ||
308 | 0x51, 0x36, | ||
309 | 0x52, 0x09, | ||
310 | 0x53, 0x94, | ||
311 | 0x54, 0x62, | ||
312 | 0x55, 0x29, | ||
313 | 0x56, 0x64, | ||
314 | 0x57, 0x2b, | ||
315 | 0xff, 0xff, | ||
316 | }; | ||
317 | |||
318 | static int stv0288_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t volt) | ||
319 | { | ||
320 | dprintk("%s: %s\n", __func__, | ||
321 | volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" : | ||
322 | volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??"); | ||
323 | |||
324 | return 0; | ||
325 | } | ||
326 | |||
327 | static int stv0288_init(struct dvb_frontend *fe) | ||
328 | { | ||
329 | struct stv0288_state *state = fe->demodulator_priv; | ||
330 | int i; | ||
331 | |||
332 | dprintk("stv0288: init chip\n"); | ||
333 | stv0288_writeregI(state, 0x41, 0x04); | ||
334 | msleep(50); | ||
335 | |||
336 | for (i = 0; !(stv0288_inittab[i] == 0xff && | ||
337 | stv0288_inittab[i + 1] == 0xff); i += 2) | ||
338 | stv0288_writeregI(state, stv0288_inittab[i], | ||
339 | stv0288_inittab[i + 1]); | ||
340 | |||
341 | return 0; | ||
342 | } | ||
343 | |||
344 | static int stv0288_read_status(struct dvb_frontend *fe, fe_status_t *status) | ||
345 | { | ||
346 | struct stv0288_state *state = fe->demodulator_priv; | ||
347 | |||
348 | u8 sync = stv0288_readreg(state, 0x24); | ||
349 | if (sync == 255) | ||
350 | sync = 0; | ||
351 | |||
352 | dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync); | ||
353 | |||
354 | *status = 0; | ||
355 | |||
356 | if ((sync & 0x08) == 0x08) { | ||
357 | *status |= FE_HAS_LOCK; | ||
358 | dprintk("stv0288 has locked\n"); | ||
359 | } | ||
360 | |||
361 | return 0; | ||
362 | } | ||
363 | |||
364 | static int stv0288_read_ber(struct dvb_frontend *fe, u32 *ber) | ||
365 | { | ||
366 | struct stv0288_state *state = fe->demodulator_priv; | ||
367 | |||
368 | if (state->errmode != STATUS_BER) | ||
369 | return 0; | ||
370 | *ber = (stv0288_readreg(state, 0x26) << 8) | | ||
371 | stv0288_readreg(state, 0x27); | ||
372 | dprintk("stv0288_read_ber %d\n", *ber); | ||
373 | |||
374 | return 0; | ||
375 | } | ||
376 | |||
377 | |||
378 | static int stv0288_read_signal_strength(struct dvb_frontend *fe, u16 *strength) | ||
379 | { | ||
380 | struct stv0288_state *state = fe->demodulator_priv; | ||
381 | |||
382 | s32 signal = 0xffff - ((stv0288_readreg(state, 0x10) << 8)); | ||
383 | |||
384 | |||
385 | signal = signal * 5 / 4; | ||
386 | *strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal; | ||
387 | dprintk("stv0288_read_signal_strength %d\n", *strength); | ||
388 | |||
389 | return 0; | ||
390 | } | ||
391 | static int stv0288_sleep(struct dvb_frontend *fe) | ||
392 | { | ||
393 | struct stv0288_state *state = fe->demodulator_priv; | ||
394 | |||
395 | stv0288_writeregI(state, 0x41, 0x84); | ||
396 | state->initialised = 0; | ||
397 | |||
398 | return 0; | ||
399 | } | ||
400 | static int stv0288_read_snr(struct dvb_frontend *fe, u16 *snr) | ||
401 | { | ||
402 | struct stv0288_state *state = fe->demodulator_priv; | ||
403 | |||
404 | s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8) | ||
405 | | stv0288_readreg(state, 0x2e)); | ||
406 | xsnr = 3 * (xsnr - 0xa100); | ||
407 | *snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr; | ||
408 | dprintk("stv0288_read_snr %d\n", *snr); | ||
409 | |||
410 | return 0; | ||
411 | } | ||
412 | |||
413 | static int stv0288_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) | ||
414 | { | ||
415 | struct stv0288_state *state = fe->demodulator_priv; | ||
416 | |||
417 | if (state->errmode != STATUS_BER) | ||
418 | return 0; | ||
419 | *ucblocks = (stv0288_readreg(state, 0x26) << 8) | | ||
420 | stv0288_readreg(state, 0x27); | ||
421 | dprintk("stv0288_read_ber %d\n", *ucblocks); | ||
422 | |||
423 | return 0; | ||
424 | } | ||
425 | |||
426 | static int stv0288_set_property(struct dvb_frontend *fe, struct dtv_property *p) | ||
427 | { | ||
428 | dprintk("%s(..)\n", __func__); | ||
429 | return 0; | ||
430 | } | ||
431 | |||
432 | static int stv0288_get_property(struct dvb_frontend *fe, struct dtv_property *p) | ||
433 | { | ||
434 | dprintk("%s(..)\n", __func__); | ||
435 | return 0; | ||
436 | } | ||
437 | |||
438 | static int stv0288_set_frontend(struct dvb_frontend *fe, | ||
439 | struct dvb_frontend_parameters *dfp) | ||
440 | { | ||
441 | struct stv0288_state *state = fe->demodulator_priv; | ||
442 | struct dtv_frontend_properties *c = &fe->dtv_property_cache; | ||
443 | |||
444 | char tm; | ||
445 | unsigned char tda[3]; | ||
446 | |||
447 | dprintk("%s : FE_SET_FRONTEND\n", __func__); | ||
448 | |||
449 | if (c->delivery_system != SYS_DVBS) { | ||
450 | dprintk("%s: unsupported delivery " | ||
451 | "system selected (%d)\n", | ||
452 | __func__, c->delivery_system); | ||
453 | return -EOPNOTSUPP; | ||
454 | } | ||
455 | |||
456 | if (state->config->set_ts_params) | ||
457 | state->config->set_ts_params(fe, 0); | ||
458 | |||
459 | /* only frequency & symbol_rate are used for tuner*/ | ||
460 | dfp->frequency = c->frequency; | ||
461 | dfp->u.qpsk.symbol_rate = c->symbol_rate; | ||
462 | if (fe->ops.tuner_ops.set_params) { | ||
463 | fe->ops.tuner_ops.set_params(fe, dfp); | ||
464 | if (fe->ops.i2c_gate_ctrl) | ||
465 | fe->ops.i2c_gate_ctrl(fe, 0); | ||
466 | } | ||
467 | |||
468 | udelay(10); | ||
469 | stv0288_set_symbolrate(fe, c->symbol_rate); | ||
470 | /* Carrier lock control register */ | ||
471 | stv0288_writeregI(state, 0x15, 0xc5); | ||
472 | |||
473 | tda[0] = 0x2b; /* CFRM */ | ||
474 | tda[2] = 0x0; /* CFRL */ | ||
475 | for (tm = -6; tm < 7;) { | ||
476 | /* Viterbi status */ | ||
477 | if (stv0288_readreg(state, 0x24) & 0x80) | ||
478 | break; | ||
479 | |||
480 | tda[2] += 40; | ||
481 | if (tda[2] < 40) | ||
482 | tm++; | ||
483 | tda[1] = (unsigned char)tm; | ||
484 | stv0288_writeregI(state, 0x2b, tda[1]); | ||
485 | stv0288_writeregI(state, 0x2c, tda[2]); | ||
486 | udelay(30); | ||
487 | } | ||
488 | |||
489 | state->tuner_frequency = c->frequency; | ||
490 | state->fec_inner = FEC_AUTO; | ||
491 | state->symbol_rate = c->symbol_rate; | ||
492 | |||
493 | return 0; | ||
494 | } | ||
495 | |||
496 | static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) | ||
497 | { | ||
498 | struct stv0288_state *state = fe->demodulator_priv; | ||
499 | |||
500 | if (enable) | ||
501 | stv0288_writeregI(state, 0x01, 0xb5); | ||
502 | else | ||
503 | stv0288_writeregI(state, 0x01, 0x35); | ||
504 | |||
505 | udelay(1); | ||
506 | |||
507 | return 0; | ||
508 | } | ||
509 | |||
510 | static void stv0288_release(struct dvb_frontend *fe) | ||
511 | { | ||
512 | struct stv0288_state *state = fe->demodulator_priv; | ||
513 | kfree(state); | ||
514 | } | ||
515 | |||
516 | static struct dvb_frontend_ops stv0288_ops = { | ||
517 | |||
518 | .info = { | ||
519 | .name = "ST STV0288 DVB-S", | ||
520 | .type = FE_QPSK, | ||
521 | .frequency_min = 950000, | ||
522 | .frequency_max = 2150000, | ||
523 | .frequency_stepsize = 1000, /* kHz for QPSK frontends */ | ||
524 | .frequency_tolerance = 0, | ||
525 | .symbol_rate_min = 1000000, | ||
526 | .symbol_rate_max = 45000000, | ||
527 | .symbol_rate_tolerance = 500, /* ppm */ | ||
528 | .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | | ||
529 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | | ||
530 | FE_CAN_QPSK | | ||
531 | FE_CAN_FEC_AUTO | ||
532 | }, | ||
533 | |||
534 | .release = stv0288_release, | ||
535 | .init = stv0288_init, | ||
536 | .sleep = stv0288_sleep, | ||
537 | .write = stv0288_write, | ||
538 | .i2c_gate_ctrl = stv0288_i2c_gate_ctrl, | ||
539 | .read_status = stv0288_read_status, | ||
540 | .read_ber = stv0288_read_ber, | ||
541 | .read_signal_strength = stv0288_read_signal_strength, | ||
542 | .read_snr = stv0288_read_snr, | ||
543 | .read_ucblocks = stv0288_read_ucblocks, | ||
544 | .diseqc_send_master_cmd = stv0288_send_diseqc_msg, | ||
545 | .diseqc_send_burst = stv0288_send_diseqc_burst, | ||
546 | .set_tone = stv0288_set_tone, | ||
547 | .set_voltage = stv0288_set_voltage, | ||
548 | |||
549 | .set_property = stv0288_set_property, | ||
550 | .get_property = stv0288_get_property, | ||
551 | .set_frontend = stv0288_set_frontend, | ||
552 | }; | ||
553 | |||
554 | struct dvb_frontend *stv0288_attach(const struct stv0288_config *config, | ||
555 | struct i2c_adapter *i2c) | ||
556 | { | ||
557 | struct stv0288_state *state = NULL; | ||
558 | int id; | ||
559 | |||
560 | /* allocate memory for the internal state */ | ||
561 | state = kmalloc(sizeof(struct stv0288_state), GFP_KERNEL); | ||
562 | if (state == NULL) | ||
563 | goto error; | ||
564 | |||
565 | /* setup the state */ | ||
566 | state->config = config; | ||
567 | state->i2c = i2c; | ||
568 | state->initialised = 0; | ||
569 | state->tuner_frequency = 0; | ||
570 | state->symbol_rate = 0; | ||
571 | state->fec_inner = 0; | ||
572 | state->errmode = STATUS_BER; | ||
573 | |||
574 | stv0288_writeregI(state, 0x41, 0x04); | ||
575 | msleep(200); | ||
576 | id = stv0288_readreg(state, 0x00); | ||
577 | dprintk("stv0288 id %x\n", id); | ||
578 | |||
579 | /* register 0x00 contains 0x11 for STV0288 */ | ||
580 | if (id != 0x11) | ||
581 | goto error; | ||
582 | |||
583 | /* create dvb_frontend */ | ||
584 | memcpy(&state->frontend.ops, &stv0288_ops, | ||
585 | sizeof(struct dvb_frontend_ops)); | ||
586 | state->frontend.demodulator_priv = state; | ||
587 | return &state->frontend; | ||
588 | |||
589 | error: | ||
590 | kfree(state); | ||
591 | |||
592 | return NULL; | ||
593 | } | ||
594 | EXPORT_SYMBOL(stv0288_attach); | ||
595 | |||
596 | module_param(debug_legacy_dish_switch, int, 0444); | ||
597 | MODULE_PARM_DESC(debug_legacy_dish_switch, | ||
598 | "Enable timing analysis for Dish Network legacy switches"); | ||
599 | |||
600 | module_param(debug, int, 0644); | ||
601 | MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); | ||
602 | |||
603 | MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver"); | ||
604 | MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin"); | ||
605 | MODULE_LICENSE("GPL"); | ||
606 | |||