blob: 9cbd164aa281dead63829e13503bbef9fd39ebe8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 TDA10021 - Single Chip Cable Channel Receiver driver module
Mauro Carvalho Chehab9101e622005-12-12 00:37:24 -08003 used on the the Siemens DVB-C cards
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5 Copyright (C) 1999 Convergence Integrated Media GmbH <ralph@convergence.de>
6 Copyright (C) 2004 Markus Schulz <msc@antzsystem.de>
Mauro Carvalho Chehab9101e622005-12-12 00:37:24 -08007 Support for TDA10021
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22*/
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/delay.h>
25#include <linux/errno.h>
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
32#include "dvb_frontend.h"
33#include "tda10021.h"
34
35
36struct tda10021_state {
37 struct i2c_adapter* i2c;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 /* configuration settings */
39 const struct tda10021_config* config;
40 struct dvb_frontend frontend;
41
42 u8 pwm;
43 u8 reg0;
44};
45
46
47#if 0
48#define dprintk(x...) printk(x)
49#else
50#define dprintk(x...)
51#endif
52
53static int verbose;
54
55#define XIN 57840000UL
56#define DISABLE_INVERSION(reg0) do { reg0 |= 0x20; } while (0)
57#define ENABLE_INVERSION(reg0) do { reg0 &= ~0x20; } while (0)
58#define HAS_INVERSION(reg0) (!(reg0 & 0x20))
59
60#define FIN (XIN >> 4)
61
62static int tda10021_inittab_size = 0x40;
63static u8 tda10021_inittab[0x40]=
64{
65 0x73, 0x6a, 0x23, 0x0a, 0x02, 0x37, 0x77, 0x1a,
66 0x37, 0x6a, 0x17, 0x8a, 0x1e, 0x86, 0x43, 0x40,
67 0xb8, 0x3f, 0xa0, 0x00, 0xcd, 0x01, 0x00, 0xff,
68 0x11, 0x00, 0x7c, 0x31, 0x30, 0x20, 0x00, 0x00,
69 0x02, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x00,
70 0x07, 0x00, 0x33, 0x11, 0x0d, 0x95, 0x08, 0x58,
71 0x00, 0x00, 0x80, 0x00, 0x80, 0xff, 0x00, 0x00,
72 0x04, 0x2d, 0x2f, 0xff, 0x00, 0x00, 0x00, 0x00,
73};
74
75static int tda10021_writereg (struct tda10021_state* state, u8 reg, u8 data)
76{
Mauro Carvalho Chehab9101e622005-12-12 00:37:24 -080077 u8 buf[] = { reg, data };
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
Mauro Carvalho Chehab9101e622005-12-12 00:37:24 -080079 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
81 ret = i2c_transfer (state->i2c, &msg, 1);
82 if (ret != 1)
83 printk("DVB: TDA10021(%d): %s, writereg error "
84 "(reg == 0x%02x, val == 0x%02x, ret == %i)\n",
85 state->frontend.dvb->num, __FUNCTION__, reg, data, ret);
86
87 msleep(10);
88 return (ret != 1) ? -EREMOTEIO : 0;
89}
90
Andrew de Quincey5c1208b2006-05-22 10:32:02 -030091int tda10021_write_byte(struct dvb_frontend* fe, int reg, int data)
92{
93 struct tda10021_state* state = fe->demodulator_priv;
94
95 return tda10021_writereg(state, reg, data);
96}
97EXPORT_SYMBOL(tda10021_write_byte);
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099static u8 tda10021_readreg (struct tda10021_state* state, u8 reg)
100{
101 u8 b0 [] = { reg };
102 u8 b1 [] = { 0 };
103 struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 1 },
Michael Krufky50c25ff2006-01-09 15:25:34 -0200104 { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 } };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 int ret;
106
107 ret = i2c_transfer (state->i2c, msg, 2);
108 if (ret != 2)
Jon Burgess88bdcc52005-09-27 21:45:26 -0700109 printk("DVB: TDA10021: %s: readreg error (ret == %i)\n",
110 __FUNCTION__, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 return b1[0];
112}
113
114//get access to tuner
115static int lock_tuner(struct tda10021_state* state)
116{
117 u8 buf[2] = { 0x0f, tda10021_inittab[0x0f] | 0x80 };
118 struct i2c_msg msg = {.addr=state->config->demod_address, .flags=0, .buf=buf, .len=2};
119
120 if(i2c_transfer(state->i2c, &msg, 1) != 1)
121 {
122 printk("tda10021: lock tuner fails\n");
123 return -EREMOTEIO;
124 }
125 return 0;
126}
127
128//release access from tuner
129static int unlock_tuner(struct tda10021_state* state)
130{
131 u8 buf[2] = { 0x0f, tda10021_inittab[0x0f] & 0x7f };
132 struct i2c_msg msg_post={.addr=state->config->demod_address, .flags=0, .buf=buf, .len=2};
133
134 if(i2c_transfer(state->i2c, &msg_post, 1) != 1)
135 {
136 printk("tda10021: unlock tuner fails\n");
137 return -EREMOTEIO;
138 }
139 return 0;
140}
141
142static int tda10021_setup_reg0 (struct tda10021_state* state, u8 reg0,
143 fe_spectral_inversion_t inversion)
144{
145 reg0 |= state->reg0 & 0x63;
146
147 if (INVERSION_ON == inversion)
148 ENABLE_INVERSION(reg0);
149 else if (INVERSION_OFF == inversion)
150 DISABLE_INVERSION(reg0);
151
152 tda10021_writereg (state, 0x00, reg0 & 0xfe);
153 tda10021_writereg (state, 0x00, reg0 | 0x01);
154
155 state->reg0 = reg0;
156 return 0;
157}
158
159static int tda10021_set_symbolrate (struct tda10021_state* state, u32 symbolrate)
160{
161 s32 BDR;
162 s32 BDRI;
163 s16 SFIL=0;
164 u16 NDEC = 0;
165 u32 tmp, ratio;
166
167 if (symbolrate > XIN/2)
168 symbolrate = XIN/2;
169 if (symbolrate < 500000)
170 symbolrate = 500000;
171
172 if (symbolrate < XIN/16) NDEC = 1;
173 if (symbolrate < XIN/32) NDEC = 2;
174 if (symbolrate < XIN/64) NDEC = 3;
175
176 if (symbolrate < (u32)(XIN/12.3)) SFIL = 1;
177 if (symbolrate < (u32)(XIN/16)) SFIL = 0;
178 if (symbolrate < (u32)(XIN/24.6)) SFIL = 1;
179 if (symbolrate < (u32)(XIN/32)) SFIL = 0;
180 if (symbolrate < (u32)(XIN/49.2)) SFIL = 1;
181 if (symbolrate < (u32)(XIN/64)) SFIL = 0;
182 if (symbolrate < (u32)(XIN/98.4)) SFIL = 1;
183
184 symbolrate <<= NDEC;
185 ratio = (symbolrate << 4) / FIN;
186 tmp = ((symbolrate << 4) % FIN) << 8;
187 ratio = (ratio << 8) + tmp / FIN;
188 tmp = (tmp % FIN) << 8;
189 ratio = (ratio << 8) + (tmp + FIN/2) / FIN;
190
191 BDR = ratio;
192 BDRI = (((XIN << 5) / symbolrate) + 1) / 2;
193
194 if (BDRI > 0xFF)
195 BDRI = 0xFF;
196
197 SFIL = (SFIL << 4) | tda10021_inittab[0x0E];
198
199 NDEC = (NDEC << 6) | tda10021_inittab[0x03];
200
201 tda10021_writereg (state, 0x03, NDEC);
202 tda10021_writereg (state, 0x0a, BDR&0xff);
203 tda10021_writereg (state, 0x0b, (BDR>> 8)&0xff);
204 tda10021_writereg (state, 0x0c, (BDR>>16)&0x3f);
205
206 tda10021_writereg (state, 0x0d, BDRI);
207 tda10021_writereg (state, 0x0e, SFIL);
208
209 return 0;
210}
211
212static int tda10021_init (struct dvb_frontend *fe)
213{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700214 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 int i;
216
217 dprintk("DVB: TDA10021(%d): init chip\n", fe->adapter->num);
218
219 //tda10021_writereg (fe, 0, 0);
220
221 for (i=0; i<tda10021_inittab_size; i++)
222 tda10021_writereg (state, i, tda10021_inittab[i]);
223
224 tda10021_writereg (state, 0x34, state->pwm);
225
226 //Comment by markus
227 //0x2A[3-0] == PDIV -> P multiplaying factor (P=PDIV+1)(default 0)
228 //0x2A[4] == BYPPLL -> Power down mode (default 1)
229 //0x2A[5] == LCK -> PLL Lock Flag
230 //0x2A[6] == POLAXIN -> Polarity of the input reference clock (default 0)
231
232 //Activate PLL
233 tda10021_writereg(state, 0x2a, tda10021_inittab[0x2a] & 0xef);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 return 0;
235}
236
237static int tda10021_set_parameters (struct dvb_frontend *fe,
238 struct dvb_frontend_parameters *p)
239{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700240 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242 //table for QAM4-QAM256 ready QAM4 QAM16 QAM32 QAM64 QAM128 QAM256
243 //CONF
244 static const u8 reg0x00 [] = { 0x14, 0x00, 0x04, 0x08, 0x0c, 0x10 };
245 //AGCREF value
246 static const u8 reg0x01 [] = { 0x78, 0x8c, 0x8c, 0x6a, 0x78, 0x5c };
247 //LTHR value
248 static const u8 reg0x05 [] = { 0x78, 0x87, 0x64, 0x46, 0x36, 0x26 };
249 //MSETH
250 static const u8 reg0x08 [] = { 0x8c, 0xa2, 0x74, 0x43, 0x34, 0x23 };
251 //AREF
252 static const u8 reg0x09 [] = { 0x96, 0x91, 0x96, 0x6a, 0x7e, 0x6b };
253
254 int qam = p->u.qam.modulation;
255
256 if (qam < 0 || qam > 5)
257 return -EINVAL;
258
259 //printk("tda10021: set frequency to %d qam=%d symrate=%d\n", p->frequency,qam,p->u.qam.symbol_rate);
260
Patrick Boettcherdea74862006-05-14 05:01:31 -0300261 if (fe->ops.tuner_ops.set_params) {
262 fe->ops.tuner_ops.set_params(fe, p);
263 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
Andrew de Quinceyf1e80912006-04-18 17:47:10 -0300264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 tda10021_set_symbolrate (state, p->u.qam.symbol_rate);
267 tda10021_writereg (state, 0x34, state->pwm);
268
269 tda10021_writereg (state, 0x01, reg0x01[qam]);
270 tda10021_writereg (state, 0x05, reg0x05[qam]);
271 tda10021_writereg (state, 0x08, reg0x08[qam]);
272 tda10021_writereg (state, 0x09, reg0x09[qam]);
273
274 tda10021_setup_reg0 (state, reg0x00[qam], p->inversion);
275
276 return 0;
277}
278
279static int tda10021_read_status(struct dvb_frontend* fe, fe_status_t* status)
280{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700281 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 int sync;
283
284 *status = 0;
285 //0x11[0] == EQALGO -> Equalizer algorithms state
286 //0x11[1] == CARLOCK -> Carrier locked
287 //0x11[2] == FSYNC -> Frame synchronisation
288 //0x11[3] == FEL -> Front End locked
289 //0x11[6] == NODVB -> DVB Mode Information
290 sync = tda10021_readreg (state, 0x11);
291
292 if (sync & 2)
293 *status |= FE_HAS_SIGNAL|FE_HAS_CARRIER;
294
295 if (sync & 4)
296 *status |= FE_HAS_SYNC|FE_HAS_VITERBI;
297
298 if (sync & 8)
299 *status |= FE_HAS_LOCK;
300
301 return 0;
302}
303
304static int tda10021_read_ber(struct dvb_frontend* fe, u32* ber)
305{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700306 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
308 u32 _ber = tda10021_readreg(state, 0x14) |
309 (tda10021_readreg(state, 0x15) << 8) |
310 ((tda10021_readreg(state, 0x16) & 0x0f) << 16);
311 *ber = 10 * _ber;
312
313 return 0;
314}
315
316static int tda10021_read_signal_strength(struct dvb_frontend* fe, u16* strength)
317{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700318 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 u8 gain = tda10021_readreg(state, 0x17);
321 *strength = (gain << 8) | gain;
322
323 return 0;
324}
325
326static int tda10021_read_snr(struct dvb_frontend* fe, u16* snr)
327{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700328 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 u8 quality = ~tda10021_readreg(state, 0x18);
331 *snr = (quality << 8) | quality;
332
333 return 0;
334}
335
336static int tda10021_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
337{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700338 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340 *ucblocks = tda10021_readreg (state, 0x13) & 0x7f;
341 if (*ucblocks == 0x7f)
342 *ucblocks = 0xffffffff;
343
344 /* reset uncorrected block counter */
345 tda10021_writereg (state, 0x10, tda10021_inittab[0x10] & 0xdf);
346 tda10021_writereg (state, 0x10, tda10021_inittab[0x10]);
347
348 return 0;
349}
350
351static int tda10021_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
352{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700353 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 int sync;
355 s8 afc = 0;
356
357 sync = tda10021_readreg(state, 0x11);
358 afc = tda10021_readreg(state, 0x19);
359 if (verbose) {
360 /* AFC only valid when carrier has been recovered */
361 printk(sync & 2 ? "DVB: TDA10021(%d): AFC (%d) %dHz\n" :
362 "DVB: TDA10021(%d): [AFC (%d) %dHz]\n",
363 state->frontend.dvb->num, afc,
364 -((s32)p->u.qam.symbol_rate * afc) >> 10);
365 }
366
367 p->inversion = HAS_INVERSION(state->reg0) ? INVERSION_ON : INVERSION_OFF;
368 p->u.qam.modulation = ((state->reg0 >> 2) & 7) + QAM_16;
369
370 p->u.qam.fec_inner = FEC_NONE;
371 p->frequency = ((p->frequency + 31250) / 62500) * 62500;
372
373 if (sync & 2)
374 p->frequency -= ((s32)p->u.qam.symbol_rate * afc) >> 10;
375
376 return 0;
377}
378
Andrew de Quinceyf1e80912006-04-18 17:47:10 -0300379static int tda10021_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
380{
381 struct tda10021_state* state = fe->demodulator_priv;
382
383 if (enable) {
384 lock_tuner(state);
385 } else {
386 unlock_tuner(state);
387 }
388 return 0;
389}
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391static int tda10021_sleep(struct dvb_frontend* fe)
392{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700393 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 tda10021_writereg (state, 0x1b, 0x02); /* pdown ADC */
396 tda10021_writereg (state, 0x00, 0x80); /* standby */
397
398 return 0;
399}
400
401static void tda10021_release(struct dvb_frontend* fe)
402{
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700403 struct tda10021_state* state = fe->demodulator_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 kfree(state);
405}
406
407static struct dvb_frontend_ops tda10021_ops;
408
409struct dvb_frontend* tda10021_attach(const struct tda10021_config* config,
410 struct i2c_adapter* i2c,
411 u8 pwm)
412{
413 struct tda10021_state* state = NULL;
414
415 /* allocate memory for the internal state */
Johannes Stezenbachb8742702005-05-16 21:54:31 -0700416 state = kmalloc(sizeof(struct tda10021_state), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 if (state == NULL) goto error;
418
419 /* setup the state */
420 state->config = config;
421 state->i2c = i2c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 state->pwm = pwm;
423 state->reg0 = tda10021_inittab[0];
424
425 /* check if the demod is there */
426 if ((tda10021_readreg(state, 0x1a) & 0xf0) != 0x70) goto error;
427
428 /* create dvb_frontend */
Patrick Boettcherdea74862006-05-14 05:01:31 -0300429 memcpy(&state->frontend.ops, &tda10021_ops, sizeof(struct dvb_frontend_ops));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 state->frontend.demodulator_priv = state;
431 return &state->frontend;
432
433error:
434 kfree(state);
435 return NULL;
436}
437
438static struct dvb_frontend_ops tda10021_ops = {
439
440 .info = {
441 .name = "Philips TDA10021 DVB-C",
442 .type = FE_QAM,
443 .frequency_stepsize = 62500,
444 .frequency_min = 51000000,
445 .frequency_max = 858000000,
446 .symbol_rate_min = (XIN/2)/64, /* SACLK/64 == (XIN/2)/64 */
447 .symbol_rate_max = (XIN/2)/4, /* SACLK/4 */
Michael Krufky50c25ff2006-01-09 15:25:34 -0200448#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 .frequency_tolerance = ???,
450 .symbol_rate_tolerance = ???, /* ppm */ /* == 8% (spec p. 5) */
451 #endif
452 .caps = 0x400 | //FE_CAN_QAM_4
453 FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
454 FE_CAN_QAM_128 | FE_CAN_QAM_256 |
455 FE_CAN_FEC_AUTO
456 },
457
458 .release = tda10021_release,
459
460 .init = tda10021_init,
461 .sleep = tda10021_sleep,
Andrew de Quinceyf1e80912006-04-18 17:47:10 -0300462 .i2c_gate_ctrl = tda10021_i2c_gate_ctrl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 .set_frontend = tda10021_set_parameters,
465 .get_frontend = tda10021_get_frontend,
466
467 .read_status = tda10021_read_status,
468 .read_ber = tda10021_read_ber,
469 .read_signal_strength = tda10021_read_signal_strength,
470 .read_snr = tda10021_read_snr,
471 .read_ucblocks = tda10021_read_ucblocks,
472};
473
474module_param(verbose, int, 0644);
475MODULE_PARM_DESC(verbose, "print AFC offset after tuning for debugging the PWM setting");
476
477MODULE_DESCRIPTION("Philips TDA10021 DVB-C demodulator driver");
478MODULE_AUTHOR("Ralph Metzler, Holger Waechtler, Markus Schulz");
479MODULE_LICENSE("GPL");
480
481EXPORT_SYMBOL(tda10021_attach);