1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * stv0367.c
4  *
5  * Driver for ST STV0367 DVB-T & DVB-C demodulator IC.
6  *
7  * Copyright (C) ST Microelectronics.
8  * Copyright (C) 2010,2011 NetUP Inc.
9  * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
10  */
11 
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/string.h>
15 #include <linux/slab.h>
16 #include <linux/i2c.h>
17 
18 #include <linux/int_log.h>
19 
20 #include "stv0367.h"
21 #include "stv0367_defs.h"
22 #include "stv0367_regs.h"
23 #include "stv0367_priv.h"
24 
25 /* Max transfer size done by I2C transfer functions */
26 #define MAX_XFER_SIZE  64
27 
28 static int stvdebug;
29 module_param_named(debug, stvdebug, int, 0644);
30 
31 static int i2cdebug;
32 module_param_named(i2c_debug, i2cdebug, int, 0644);
33 
34 #define dprintk(args...) \
35 	do { \
36 		if (stvdebug) \
37 			printk(KERN_DEBUG args); \
38 	} while (0)
39 	/* DVB-C */
40 
41 enum active_demod_state { demod_none, demod_ter, demod_cab };
42 
43 struct stv0367cab_state {
44 	enum stv0367_cab_signal_type	state;
45 	u32	mclk;
46 	u32	adc_clk;
47 	s32	search_range;
48 	s32	derot_offset;
49 	/* results */
50 	int locked;			/* channel found		*/
51 	u32 freq_khz;			/* found frequency (in kHz)	*/
52 	u32 symbol_rate;		/* found symbol rate (in Bds)	*/
53 	enum fe_spectral_inversion spect_inv; /* Spectrum Inversion	*/
54 	u32 qamfec_status_reg;          /* status reg to poll for FEC Lock */
55 };
56 
57 struct stv0367ter_state {
58 	/* DVB-T */
59 	enum stv0367_ter_signal_type state;
60 	enum stv0367_ter_if_iq_mode if_iq_mode;
61 	enum stv0367_ter_mode mode;/* mode 2K or 8K */
62 	enum fe_guard_interval guard;
63 	enum stv0367_ter_hierarchy hierarchy;
64 	u32 frequency;
65 	enum fe_spectral_inversion sense; /*  current search spectrum */
66 	u8  force; /* force mode/guard */
67 	u8  bw; /* channel width 6, 7 or 8 in MHz */
68 	u8  pBW; /* channel width used during previous lock */
69 	u32 pBER;
70 	u32 pPER;
71 	u32 ucblocks;
72 	s8  echo_pos; /* echo position */
73 	u8  first_lock;
74 	u8  unlock_counter;
75 	u32 agc_val;
76 };
77 
78 struct stv0367_state {
79 	struct dvb_frontend fe;
80 	struct i2c_adapter *i2c;
81 	/* config settings */
82 	const struct stv0367_config *config;
83 	u8 chip_id;
84 	/* DVB-C */
85 	struct stv0367cab_state *cab_state;
86 	/* DVB-T */
87 	struct stv0367ter_state *ter_state;
88 	/* flags for operation control */
89 	u8 use_i2c_gatectrl;
90 	u8 deftabs;
91 	u8 reinit_on_setfrontend;
92 	u8 auto_if_khz;
93 	enum active_demod_state activedemod;
94 };
95 
96 #define RF_LOOKUP_TABLE_SIZE  31
97 #define RF_LOOKUP_TABLE2_SIZE 16
98 /* RF Level (for RF AGC->AGC1) Lookup Table, depends on the board and tuner.*/
99 static const s32 stv0367cab_RF_LookUp1[RF_LOOKUP_TABLE_SIZE][RF_LOOKUP_TABLE_SIZE] = {
100 	{/*AGC1*/
101 		48, 50, 51, 53, 54, 56, 57, 58, 60, 61, 62, 63,
102 		64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
103 		76, 77, 78, 80, 83, 85, 88,
104 	}, {/*RF(dbm)*/
105 		22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
106 		34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 46, 47,
107 		49, 50, 52, 53, 54, 55, 56,
108 	}
109 };
110 /* RF Level (for IF AGC->AGC2) Lookup Table, depends on the board and tuner.*/
111 static const s32 stv0367cab_RF_LookUp2[RF_LOOKUP_TABLE2_SIZE][RF_LOOKUP_TABLE2_SIZE] = {
112 	{/*AGC2*/
113 		28, 29, 31, 32, 34, 35, 36, 37,
114 		38, 39, 40, 41, 42, 43, 44, 45,
115 	}, {/*RF(dbm)*/
116 		57, 58, 59, 60, 61, 62, 63, 64,
117 		65, 66, 67, 68, 69, 70, 71, 72,
118 	}
119 };
120 
121 static noinline_for_stack
122 int stv0367_writereg(struct stv0367_state *state, u16 reg, u8 data)
123 {
124 	u8 buf[3] = { MSB(reg), LSB(reg), data };
125 	struct i2c_msg msg = {
126 		.addr = state->config->demod_address,
127 		.flags = 0,
128 		.buf = buf,
129 		.len = 3,
130 	};
131 	int ret;
132 
133 	if (i2cdebug)
134 		printk(KERN_DEBUG "%s: [%02x] %02x: %02x\n", __func__,
135 			state->config->demod_address, reg, data);
136 
137 	ret = i2c_transfer(state->i2c, &msg, 1);
138 	if (ret != 1)
139 		printk(KERN_ERR "%s: i2c write error! ([%02x] %02x: %02x)\n",
140 			__func__, state->config->demod_address, reg, data);
141 
142 	return (ret != 1) ? -EREMOTEIO : 0;
143 }
144 
145 static noinline_for_stack
146 u8 stv0367_readreg(struct stv0367_state *state, u16 reg)
147 {
148 	u8 b0[] = { 0, 0 };
149 	u8 b1[] = { 0 };
150 	struct i2c_msg msg[] = {
151 		{
152 			.addr = state->config->demod_address,
153 			.flags = 0,
154 			.buf = b0,
155 			.len = 2
156 		}, {
157 			.addr = state->config->demod_address,
158 			.flags = I2C_M_RD,
159 			.buf = b1,
160 			.len = 1
161 		}
162 	};
163 	int ret;
164 
165 	b0[0] = MSB(reg);
166 	b0[1] = LSB(reg);
167 
168 	ret = i2c_transfer(state->i2c, msg, 2);
169 	if (ret != 2)
170 		printk(KERN_ERR "%s: i2c read error ([%02x] %02x: %02x)\n",
171 			__func__, state->config->demod_address, reg, b1[0]);
172 
173 	if (i2cdebug)
174 		printk(KERN_DEBUG "%s: [%02x] %02x: %02x\n", __func__,
175 			state->config->demod_address, reg, b1[0]);
176 
177 	return b1[0];
178 }
179 
180 static void extract_mask_pos(u32 label, u8 *mask, u8 *pos)
181 {
182 	u8 position = 0, i = 0;
183 
184 	(*mask) = label & 0xff;
185 
186 	while ((position == 0) && (i < 8)) {
187 		position = ((*mask) >> i) & 0x01;
188 		i++;
189 	}
190 
191 	(*pos) = (i - 1);
192 }
193 
194 static void stv0367_writebits(struct stv0367_state *state, u32 label, u8 val)
195 {
196 	u8 reg, mask, pos;
197 
198 	reg = stv0367_readreg(state, (label >> 16) & 0xffff);
199 	extract_mask_pos(label, &mask, &pos);
200 
201 	val = mask & (val << pos);
202 
203 	reg = (reg & (~mask)) | val;
204 	stv0367_writereg(state, (label >> 16) & 0xffff, reg);
205 
206 }
207 
208 static void stv0367_setbits(u8 *reg, u32 label, u8 val)
209 {
210 	u8 mask, pos;
211 
212 	extract_mask_pos(label, &mask, &pos);
213 
214 	val = mask & (val << pos);
215 
216 	(*reg) = ((*reg) & (~mask)) | val;
217 }
218 
219 static u8 stv0367_readbits(struct stv0367_state *state, u32 label)
220 {
221 	u8 val = 0xff;
222 	u8 mask, pos;
223 
224 	extract_mask_pos(label, &mask, &pos);
225 
226 	val = stv0367_readreg(state, label >> 16);
227 	val = (val & mask) >> pos;
228 
229 	return val;
230 }
231 
232 #if 0 /* Currently, unused */
233 static u8 stv0367_getbits(u8 reg, u32 label)
234 {
235 	u8 mask, pos;
236 
237 	extract_mask_pos(label, &mask, &pos);
238 
239 	return (reg & mask) >> pos;
240 }
241 #endif
242 
243 static void stv0367_write_table(struct stv0367_state *state,
244 				const struct st_register *deftab)
245 {
246 	int i = 0;
247 
248 	while (1) {
249 		if (!deftab[i].addr)
250 			break;
251 		stv0367_writereg(state, deftab[i].addr, deftab[i].value);
252 		i++;
253 	}
254 }
255 
256 static void stv0367_pll_setup(struct stv0367_state *state,
257 				u32 icspeed, u32 xtal)
258 {
259 	/* note on regs: R367TER_* and R367CAB_* defines each point to
260 	 * 0xf0d8, so just use R367TER_ for both cases
261 	 */
262 
263 	switch (icspeed) {
264 	case STV0367_ICSPEED_58000:
265 		switch (xtal) {
266 		default:
267 		case 27000000:
268 			dprintk("STV0367 SetCLKgen for 58MHz IC and 27Mhz crystal\n");
269 			/* PLLMDIV: 27, PLLNDIV: 232 */
270 			stv0367_writereg(state, R367TER_PLLMDIV, 0x1b);
271 			stv0367_writereg(state, R367TER_PLLNDIV, 0xe8);
272 			break;
273 		}
274 		break;
275 	default:
276 	case STV0367_ICSPEED_53125:
277 		switch (xtal) {
278 			/* set internal freq to 53.125MHz */
279 		case 16000000:
280 			stv0367_writereg(state, R367TER_PLLMDIV, 0x2);
281 			stv0367_writereg(state, R367TER_PLLNDIV, 0x1b);
282 			break;
283 		case 25000000:
284 			stv0367_writereg(state, R367TER_PLLMDIV, 0xa);
285 			stv0367_writereg(state, R367TER_PLLNDIV, 0x55);
286 			break;
287 		default:
288 		case 27000000:
289 			dprintk("FE_STV0367TER_SetCLKgen for 27Mhz\n");
290 			stv0367_writereg(state, R367TER_PLLMDIV, 0x1);
291 			stv0367_writereg(state, R367TER_PLLNDIV, 0x8);
292 			break;
293 		case 30000000:
294 			stv0367_writereg(state, R367TER_PLLMDIV, 0xc);
295 			stv0367_writereg(state, R367TER_PLLNDIV, 0x55);
296 			break;
297 		}
298 	}
299 
300 	stv0367_writereg(state, R367TER_PLLSETUP, 0x18);
301 }
302 
303 static int stv0367_get_if_khz(struct stv0367_state *state, u32 *ifkhz)
304 {
305 	if (state->auto_if_khz && state->fe.ops.tuner_ops.get_if_frequency) {
306 		state->fe.ops.tuner_ops.get_if_frequency(&state->fe, ifkhz);
307 		*ifkhz = *ifkhz / 1000; /* hz -> khz */
308 	} else
309 		*ifkhz = state->config->if_khz;
310 
311 	return 0;
312 }
313 
314 static int stv0367ter_gate_ctrl(struct dvb_frontend *fe, int enable)
315 {
316 	struct stv0367_state *state = fe->demodulator_priv;
317 	u8 tmp = stv0367_readreg(state, R367TER_I2CRPT);
318 
319 	dprintk("%s:\n", __func__);
320 
321 	if (enable) {
322 		stv0367_setbits(&tmp, F367TER_STOP_ENABLE, 0);
323 		stv0367_setbits(&tmp, F367TER_I2CT_ON, 1);
324 	} else {
325 		stv0367_setbits(&tmp, F367TER_STOP_ENABLE, 1);
326 		stv0367_setbits(&tmp, F367TER_I2CT_ON, 0);
327 	}
328 
329 	stv0367_writereg(state, R367TER_I2CRPT, tmp);
330 
331 	return 0;
332 }
333 
334 static u32 stv0367_get_tuner_freq(struct dvb_frontend *fe)
335 {
336 	struct dvb_frontend_ops	*frontend_ops = &fe->ops;
337 	struct dvb_tuner_ops	*tuner_ops = &frontend_ops->tuner_ops;
338 	u32 freq = 0;
339 	int err = 0;
340 
341 	dprintk("%s:\n", __func__);
342 
343 	if (tuner_ops->get_frequency) {
344 		err = tuner_ops->get_frequency(fe, &freq);
345 		if (err < 0) {
346 			printk(KERN_ERR "%s: Invalid parameter\n", __func__);
347 			return err;
348 		}
349 
350 		dprintk("%s: frequency=%d\n", __func__, freq);
351 
352 	} else
353 		return -1;
354 
355 	return freq;
356 }
357 
358 static u16 CellsCoeffs_8MHz_367cofdm[3][6][5] = {
359 	{
360 		{0x10EF, 0xE205, 0x10EF, 0xCE49, 0x6DA7}, /* CELL 1 COEFFS 27M*/
361 		{0x2151, 0xc557, 0x2151, 0xc705, 0x6f93}, /* CELL 2 COEFFS */
362 		{0x2503, 0xc000, 0x2503, 0xc375, 0x7194}, /* CELL 3 COEFFS */
363 		{0x20E9, 0xca94, 0x20e9, 0xc153, 0x7194}, /* CELL 4 COEFFS */
364 		{0x06EF, 0xF852, 0x06EF, 0xC057, 0x7207}, /* CELL 5 COEFFS */
365 		{0x0000, 0x0ECC, 0x0ECC, 0x0000, 0x3647} /* CELL 6 COEFFS */
366 	}, {
367 		{0x10A0, 0xE2AF, 0x10A1, 0xCE76, 0x6D6D}, /* CELL 1 COEFFS 25M*/
368 		{0x20DC, 0xC676, 0x20D9, 0xC80A, 0x6F29},
369 		{0x2532, 0xC000, 0x251D, 0xC391, 0x706F},
370 		{0x1F7A, 0xCD2B, 0x2032, 0xC15E, 0x711F},
371 		{0x0698, 0xFA5E, 0x0568, 0xC059, 0x7193},
372 		{0x0000, 0x0918, 0x149C, 0x0000, 0x3642} /* CELL 6 COEFFS */
373 	}, {
374 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, /* 30M */
375 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
376 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
377 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
378 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
379 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000}
380 	}
381 };
382 
383 static u16 CellsCoeffs_7MHz_367cofdm[3][6][5] = {
384 	{
385 		{0x12CA, 0xDDAF, 0x12CA, 0xCCEB, 0x6FB1}, /* CELL 1 COEFFS 27M*/
386 		{0x2329, 0xC000, 0x2329, 0xC6B0, 0x725F}, /* CELL 2 COEFFS */
387 		{0x2394, 0xC000, 0x2394, 0xC2C7, 0x7410}, /* CELL 3 COEFFS */
388 		{0x251C, 0xC000, 0x251C, 0xC103, 0x74D9}, /* CELL 4 COEFFS */
389 		{0x0804, 0xF546, 0x0804, 0xC040, 0x7544}, /* CELL 5 COEFFS */
390 		{0x0000, 0x0CD9, 0x0CD9, 0x0000, 0x370A} /* CELL 6 COEFFS */
391 	}, {
392 		{0x1285, 0xDE47, 0x1285, 0xCD17, 0x6F76}, /*25M*/
393 		{0x234C, 0xC000, 0x2348, 0xC6DA, 0x7206},
394 		{0x23B4, 0xC000, 0x23AC, 0xC2DB, 0x73B3},
395 		{0x253D, 0xC000, 0x25B6, 0xC10B, 0x747F},
396 		{0x0721, 0xF79C, 0x065F, 0xC041, 0x74EB},
397 		{0x0000, 0x08FA, 0x1162, 0x0000, 0x36FF}
398 	}, {
399 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, /* 30M */
400 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
401 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
402 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
403 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
404 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000}
405 	}
406 };
407 
408 static u16 CellsCoeffs_6MHz_367cofdm[3][6][5] = {
409 	{
410 		{0x1699, 0xD5B8, 0x1699, 0xCBC3, 0x713B}, /* CELL 1 COEFFS 27M*/
411 		{0x2245, 0xC000, 0x2245, 0xC568, 0x74D5}, /* CELL 2 COEFFS */
412 		{0x227F, 0xC000, 0x227F, 0xC1FC, 0x76C6}, /* CELL 3 COEFFS */
413 		{0x235E, 0xC000, 0x235E, 0xC0A7, 0x778A}, /* CELL 4 COEFFS */
414 		{0x0ECB, 0xEA0B, 0x0ECB, 0xC027, 0x77DD}, /* CELL 5 COEFFS */
415 		{0x0000, 0x0B68, 0x0B68, 0x0000, 0xC89A}, /* CELL 6 COEFFS */
416 	}, {
417 		{0x1655, 0xD64E, 0x1658, 0xCBEF, 0x70FE}, /*25M*/
418 		{0x225E, 0xC000, 0x2256, 0xC589, 0x7489},
419 		{0x2293, 0xC000, 0x2295, 0xC209, 0x767E},
420 		{0x2377, 0xC000, 0x23AA, 0xC0AB, 0x7746},
421 		{0x0DC7, 0xEBC8, 0x0D07, 0xC027, 0x7799},
422 		{0x0000, 0x0888, 0x0E9C, 0x0000, 0x3757}
423 
424 	}, {
425 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, /* 30M */
426 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
427 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
428 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
429 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
430 		{0x0000, 0x0000, 0x0000, 0x0000, 0x0000}
431 	}
432 };
433 
434 static u32 stv0367ter_get_mclk(struct stv0367_state *state, u32 ExtClk_Hz)
435 {
436 	u32 mclk_Hz = 0; /* master clock frequency (Hz) */
437 	u32 m, n, p;
438 
439 	dprintk("%s:\n", __func__);
440 
441 	if (stv0367_readbits(state, F367TER_BYPASS_PLLXN) == 0) {
442 		n = (u32)stv0367_readbits(state, F367TER_PLL_NDIV);
443 		if (n == 0)
444 			n = n + 1;
445 
446 		m = (u32)stv0367_readbits(state, F367TER_PLL_MDIV);
447 		if (m == 0)
448 			m = m + 1;
449 
450 		p = (u32)stv0367_readbits(state, F367TER_PLL_PDIV);
451 		if (p > 5)
452 			p = 5;
453 
454 		mclk_Hz = ((ExtClk_Hz / 2) * n) / (m * (1 << p));
455 
456 		dprintk("N=%d M=%d P=%d mclk_Hz=%d ExtClk_Hz=%d\n",
457 				n, m, p, mclk_Hz, ExtClk_Hz);
458 	} else
459 		mclk_Hz = ExtClk_Hz;
460 
461 	dprintk("%s: mclk_Hz=%d\n", __func__, mclk_Hz);
462 
463 	return mclk_Hz;
464 }
465 
466 static int stv0367ter_filt_coeff_init(struct stv0367_state *state,
467 				u16 CellsCoeffs[3][6][5], u32 DemodXtal)
468 {
469 	int i, j, k, freq;
470 
471 	dprintk("%s:\n", __func__);
472 
473 	freq = stv0367ter_get_mclk(state, DemodXtal);
474 
475 	if (freq == 53125000)
476 		k = 1; /* equivalent to Xtal 25M on 362*/
477 	else if (freq == 54000000)
478 		k = 0; /* equivalent to Xtal 27M on 362*/
479 	else if (freq == 52500000)
480 		k = 2; /* equivalent to Xtal 30M on 362*/
481 	else
482 		return 0;
483 
484 	for (i = 1; i <= 6; i++) {
485 		stv0367_writebits(state, F367TER_IIR_CELL_NB, i - 1);
486 
487 		for (j = 1; j <= 5; j++) {
488 			stv0367_writereg(state,
489 				(R367TER_IIRCX_COEFF1_MSB + 2 * (j - 1)),
490 				MSB(CellsCoeffs[k][i-1][j-1]));
491 			stv0367_writereg(state,
492 				(R367TER_IIRCX_COEFF1_LSB + 2 * (j - 1)),
493 				LSB(CellsCoeffs[k][i-1][j-1]));
494 		}
495 	}
496 
497 	return 1;
498 
499 }
500 
501 static void stv0367ter_agc_iir_lock_detect_set(struct stv0367_state *state)
502 {
503 	dprintk("%s:\n", __func__);
504 
505 	stv0367_writebits(state, F367TER_LOCK_DETECT_LSB, 0x00);
506 
507 	/* Lock detect 1 */
508 	stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x00);
509 	stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x06);
510 	stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x04);
511 
512 	/* Lock detect 2 */
513 	stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x01);
514 	stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x06);
515 	stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x04);
516 
517 	/* Lock detect 3 */
518 	stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x02);
519 	stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x01);
520 	stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x00);
521 
522 	/* Lock detect 4 */
523 	stv0367_writebits(state, F367TER_LOCK_DETECT_CHOICE, 0x03);
524 	stv0367_writebits(state, F367TER_LOCK_DETECT_MSB, 0x01);
525 	stv0367_writebits(state, F367TER_AUT_AGC_TARGET_LSB, 0x00);
526 
527 }
528 
529 static int stv0367_iir_filt_init(struct stv0367_state *state, u8 Bandwidth,
530 							u32 DemodXtalValue)
531 {
532 	dprintk("%s:\n", __func__);
533 
534 	stv0367_writebits(state, F367TER_NRST_IIR, 0);
535 
536 	switch (Bandwidth) {
537 	case 6:
538 		if (!stv0367ter_filt_coeff_init(state,
539 				CellsCoeffs_6MHz_367cofdm,
540 				DemodXtalValue))
541 			return 0;
542 		break;
543 	case 7:
544 		if (!stv0367ter_filt_coeff_init(state,
545 				CellsCoeffs_7MHz_367cofdm,
546 				DemodXtalValue))
547 			return 0;
548 		break;
549 	case 8:
550 		if (!stv0367ter_filt_coeff_init(state,
551 				CellsCoeffs_8MHz_367cofdm,
552 				DemodXtalValue))
553 			return 0;
554 		break;
555 	default:
556 		return 0;
557 	}
558 
559 	stv0367_writebits(state, F367TER_NRST_IIR, 1);
560 
561 	return 1;
562 }
563 
564 static void stv0367ter_agc_iir_rst(struct stv0367_state *state)
565 {
566 
567 	u8 com_n;
568 
569 	dprintk("%s:\n", __func__);
570 
571 	com_n = stv0367_readbits(state, F367TER_COM_N);
572 
573 	stv0367_writebits(state, F367TER_COM_N, 0x07);
574 
575 	stv0367_writebits(state, F367TER_COM_SOFT_RSTN, 0x00);
576 	stv0367_writebits(state, F367TER_COM_AGC_ON, 0x00);
577 
578 	stv0367_writebits(state, F367TER_COM_SOFT_RSTN, 0x01);
579 	stv0367_writebits(state, F367TER_COM_AGC_ON, 0x01);
580 
581 	stv0367_writebits(state, F367TER_COM_N, com_n);
582 
583 }
584 
585 static int stv0367ter_duration(s32 mode, int tempo1, int tempo2, int tempo3)
586 {
587 	int local_tempo = 0;
588 	switch (mode) {
589 	case 0:
590 		local_tempo = tempo1;
591 		break;
592 	case 1:
593 		local_tempo = tempo2;
594 		break ;
595 
596 	case 2:
597 		local_tempo = tempo3;
598 		break;
599 
600 	default:
601 		break;
602 	}
603 	/*	msleep(local_tempo);  */
604 	return local_tempo;
605 }
606 
607 static enum
608 stv0367_ter_signal_type stv0367ter_check_syr(struct stv0367_state *state)
609 {
610 	int wd = 100;
611 	unsigned short int SYR_var;
612 	s32 SYRStatus;
613 
614 	dprintk("%s:\n", __func__);
615 
616 	SYR_var = stv0367_readbits(state, F367TER_SYR_LOCK);
617 
618 	while ((!SYR_var) && (wd > 0)) {
619 		usleep_range(2000, 3000);
620 		wd -= 2;
621 		SYR_var = stv0367_readbits(state, F367TER_SYR_LOCK);
622 	}
623 
624 	if (!SYR_var)
625 		SYRStatus = FE_TER_NOSYMBOL;
626 	else
627 		SYRStatus =  FE_TER_SYMBOLOK;
628 
629 	dprintk("stv0367ter_check_syr SYRStatus %s\n",
630 				SYR_var == 0 ? "No Symbol" : "OK");
631 
632 	return SYRStatus;
633 }
634 
635 static enum
636 stv0367_ter_signal_type stv0367ter_check_cpamp(struct stv0367_state *state,
637 								s32 FFTmode)
638 {
639 
640 	s32  CPAMPvalue = 0, CPAMPStatus, CPAMPMin;
641 	int wd = 0;
642 
643 	dprintk("%s:\n", __func__);
644 
645 	switch (FFTmode) {
646 	case 0: /*2k mode*/
647 		CPAMPMin = 20;
648 		wd = 10;
649 		break;
650 	case 1: /*8k mode*/
651 		CPAMPMin = 80;
652 		wd = 55;
653 		break;
654 	case 2: /*4k mode*/
655 		CPAMPMin = 40;
656 		wd = 30;
657 		break;
658 	default:
659 		CPAMPMin = 0xffff;  /*drives to NOCPAMP	*/
660 		break;
661 	}
662 
663 	dprintk("%s: CPAMPMin=%d wd=%d\n", __func__, CPAMPMin, wd);
664 
665 	CPAMPvalue = stv0367_readbits(state, F367TER_PPM_CPAMP_DIRECT);
666 	while ((CPAMPvalue < CPAMPMin) && (wd > 0)) {
667 		usleep_range(1000, 2000);
668 		wd -= 1;
669 		CPAMPvalue = stv0367_readbits(state, F367TER_PPM_CPAMP_DIRECT);
670 		/*dprintk("CPAMPvalue= %d at wd=%d\n",CPAMPvalue,wd); */
671 	}
672 	dprintk("******last CPAMPvalue= %d at wd=%d\n", CPAMPvalue, wd);
673 	if (CPAMPvalue < CPAMPMin) {
674 		CPAMPStatus = FE_TER_NOCPAMP;
675 		dprintk("%s: CPAMP failed\n", __func__);
676 	} else {
677 		dprintk("%s: CPAMP OK !\n", __func__);
678 		CPAMPStatus = FE_TER_CPAMPOK;
679 	}
680 
681 	return CPAMPStatus;
682 }
683 
684 static enum stv0367_ter_signal_type
685 stv0367ter_lock_algo(struct stv0367_state *state)
686 {
687 	enum stv0367_ter_signal_type ret_flag;
688 	short int wd, tempo;
689 	u8 try, u_var1 = 0, u_var2 = 0, u_var3 = 0, u_var4 = 0, mode, guard;
690 	u8 tmp, tmp2;
691 
692 	dprintk("%s:\n", __func__);
693 
694 	if (state == NULL)
695 		return FE_TER_SWNOK;
696 
697 	try = 0;
698 	do {
699 		ret_flag = FE_TER_LOCKOK;
700 
701 		stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
702 
703 		if (state->config->if_iq_mode != 0)
704 			stv0367_writebits(state, F367TER_COM_N, 0x07);
705 
706 		stv0367_writebits(state, F367TER_GUARD, 3);/* suggest 2k 1/4 */
707 		stv0367_writebits(state, F367TER_MODE, 0);
708 		stv0367_writebits(state, F367TER_SYR_TR_DIS, 0);
709 		usleep_range(5000, 10000);
710 
711 		stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
712 
713 
714 		if (stv0367ter_check_syr(state) == FE_TER_NOSYMBOL)
715 			return FE_TER_NOSYMBOL;
716 		else { /*
717 			if chip locked on wrong mode first try,
718 			it must lock correctly second try */
719 			mode = stv0367_readbits(state, F367TER_SYR_MODE);
720 			if (stv0367ter_check_cpamp(state, mode) ==
721 							FE_TER_NOCPAMP) {
722 				if (try == 0)
723 					ret_flag = FE_TER_NOCPAMP;
724 
725 			}
726 		}
727 
728 		try++;
729 	} while ((try < 10) && (ret_flag != FE_TER_LOCKOK));
730 
731 	tmp  = stv0367_readreg(state, R367TER_SYR_STAT);
732 	tmp2 = stv0367_readreg(state, R367TER_STATUS);
733 	dprintk("state=%p\n", state);
734 	dprintk("LOCK OK! mode=%d SYR_STAT=0x%x R367TER_STATUS=0x%x\n",
735 							mode, tmp, tmp2);
736 
737 	tmp  = stv0367_readreg(state, R367TER_PRVIT);
738 	tmp2 = stv0367_readreg(state, R367TER_I2CRPT);
739 	dprintk("PRVIT=0x%x I2CRPT=0x%x\n", tmp, tmp2);
740 
741 	tmp  = stv0367_readreg(state, R367TER_GAIN_SRC1);
742 	dprintk("GAIN_SRC1=0x%x\n", tmp);
743 
744 	if ((mode != 0) && (mode != 1) && (mode != 2))
745 		return FE_TER_SWNOK;
746 
747 	/*guard=stv0367_readbits(state,F367TER_SYR_GUARD); */
748 
749 	/*suppress EPQ auto for SYR_GARD 1/16 or 1/32
750 	and set channel predictor in automatic */
751 #if 0
752 	switch (guard) {
753 
754 	case 0:
755 	case 1:
756 		stv0367_writebits(state, F367TER_AUTO_LE_EN, 0);
757 		stv0367_writereg(state, R367TER_CHC_CTL, 0x01);
758 		break;
759 	case 2:
760 	case 3:
761 		stv0367_writebits(state, F367TER_AUTO_LE_EN, 1);
762 		stv0367_writereg(state, R367TER_CHC_CTL, 0x11);
763 		break;
764 
765 	default:
766 		return FE_TER_SWNOK;
767 	}
768 #endif
769 
770 	/*reset fec an reedsolo FOR 367 only*/
771 	stv0367_writebits(state, F367TER_RST_SFEC, 1);
772 	stv0367_writebits(state, F367TER_RST_REEDSOLO, 1);
773 	usleep_range(1000, 2000);
774 	stv0367_writebits(state, F367TER_RST_SFEC, 0);
775 	stv0367_writebits(state, F367TER_RST_REEDSOLO, 0);
776 
777 	u_var1 = stv0367_readbits(state, F367TER_LK);
778 	u_var2 = stv0367_readbits(state, F367TER_PRF);
779 	u_var3 = stv0367_readbits(state, F367TER_TPS_LOCK);
780 	/*	u_var4=stv0367_readbits(state,F367TER_TSFIFO_LINEOK); */
781 
782 	wd = stv0367ter_duration(mode, 125, 500, 250);
783 	tempo = stv0367ter_duration(mode, 4, 16, 8);
784 
785 	/*while ( ((!u_var1)||(!u_var2)||(!u_var3)||(!u_var4))  && (wd>=0)) */
786 	while (((!u_var1) || (!u_var2) || (!u_var3)) && (wd >= 0)) {
787 		usleep_range(1000 * tempo, 1000 * (tempo + 1));
788 		wd -= tempo;
789 		u_var1 = stv0367_readbits(state, F367TER_LK);
790 		u_var2 = stv0367_readbits(state, F367TER_PRF);
791 		u_var3 = stv0367_readbits(state, F367TER_TPS_LOCK);
792 		/*u_var4=stv0367_readbits(state, F367TER_TSFIFO_LINEOK); */
793 	}
794 
795 	if (!u_var1)
796 		return FE_TER_NOLOCK;
797 
798 
799 	if (!u_var2)
800 		return FE_TER_NOPRFOUND;
801 
802 	if (!u_var3)
803 		return FE_TER_NOTPS;
804 
805 	guard = stv0367_readbits(state, F367TER_SYR_GUARD);
806 	stv0367_writereg(state, R367TER_CHC_CTL, 0x11);
807 	switch (guard) {
808 	case 0:
809 	case 1:
810 		stv0367_writebits(state, F367TER_AUTO_LE_EN, 0);
811 		/*stv0367_writereg(state,R367TER_CHC_CTL, 0x1);*/
812 		stv0367_writebits(state, F367TER_SYR_FILTER, 0);
813 		break;
814 	case 2:
815 	case 3:
816 		stv0367_writebits(state, F367TER_AUTO_LE_EN, 1);
817 		/*stv0367_writereg(state,R367TER_CHC_CTL, 0x11);*/
818 		stv0367_writebits(state, F367TER_SYR_FILTER, 1);
819 		break;
820 
821 	default:
822 		return FE_TER_SWNOK;
823 	}
824 
825 	/* apply Sfec workaround if 8K 64QAM CR!=1/2*/
826 	if ((stv0367_readbits(state, F367TER_TPS_CONST) == 2) &&
827 			(mode == 1) &&
828 			(stv0367_readbits(state, F367TER_TPS_HPCODE) != 0)) {
829 		stv0367_writereg(state, R367TER_SFDLYSETH, 0xc0);
830 		stv0367_writereg(state, R367TER_SFDLYSETM, 0x60);
831 		stv0367_writereg(state, R367TER_SFDLYSETL, 0x0);
832 	} else
833 		stv0367_writereg(state, R367TER_SFDLYSETH, 0x0);
834 
835 	wd = stv0367ter_duration(mode, 125, 500, 250);
836 	u_var4 = stv0367_readbits(state, F367TER_TSFIFO_LINEOK);
837 
838 	while ((!u_var4) && (wd >= 0)) {
839 		usleep_range(1000 * tempo, 1000 * (tempo + 1));
840 		wd -= tempo;
841 		u_var4 = stv0367_readbits(state, F367TER_TSFIFO_LINEOK);
842 	}
843 
844 	if (!u_var4)
845 		return FE_TER_NOLOCK;
846 
847 	/* for 367 leave COM_N at 0x7 for IQ_mode*/
848 	/*if(ter_state->if_iq_mode!=FE_TER_NORMAL_IF_TUNER) {
849 		tempo=0;
850 		while ((stv0367_readbits(state,F367TER_COM_USEGAINTRK)!=1) &&
851 		(stv0367_readbits(state,F367TER_COM_AGCLOCK)!=1)&&(tempo<100)) {
852 			ChipWaitOrAbort(state,1);
853 			tempo+=1;
854 		}
855 
856 		stv0367_writebits(state,F367TER_COM_N,0x17);
857 	} */
858 
859 	stv0367_writebits(state, F367TER_SYR_TR_DIS, 1);
860 
861 	dprintk("FE_TER_LOCKOK !!!\n");
862 
863 	return	FE_TER_LOCKOK;
864 
865 }
866 
867 static void stv0367ter_set_ts_mode(struct stv0367_state *state,
868 					enum stv0367_ts_mode PathTS)
869 {
870 
871 	dprintk("%s:\n", __func__);
872 
873 	if (state == NULL)
874 		return;
875 
876 	stv0367_writebits(state, F367TER_TS_DIS, 0);
877 	switch (PathTS) {
878 	default:
879 		/*for removing warning :default we can assume in parallel mode*/
880 	case STV0367_PARALLEL_PUNCT_CLOCK:
881 		stv0367_writebits(state, F367TER_TSFIFO_SERIAL, 0);
882 		stv0367_writebits(state, F367TER_TSFIFO_DVBCI, 0);
883 		break;
884 	case STV0367_SERIAL_PUNCT_CLOCK:
885 		stv0367_writebits(state, F367TER_TSFIFO_SERIAL, 1);
886 		stv0367_writebits(state, F367TER_TSFIFO_DVBCI, 1);
887 		break;
888 	}
889 }
890 
891 static void stv0367ter_set_clk_pol(struct stv0367_state *state,
892 					enum stv0367_clk_pol clock)
893 {
894 
895 	dprintk("%s:\n", __func__);
896 
897 	if (state == NULL)
898 		return;
899 
900 	switch (clock) {
901 	case STV0367_RISINGEDGE_CLOCK:
902 		stv0367_writebits(state, F367TER_TS_BYTE_CLK_INV, 1);
903 		break;
904 	case STV0367_FALLINGEDGE_CLOCK:
905 		stv0367_writebits(state, F367TER_TS_BYTE_CLK_INV, 0);
906 		break;
907 		/*case FE_TER_CLOCK_POLARITY_DEFAULT:*/
908 	default:
909 		stv0367_writebits(state, F367TER_TS_BYTE_CLK_INV, 0);
910 		break;
911 	}
912 }
913 
914 #if 0
915 static void stv0367ter_core_sw(struct stv0367_state *state)
916 {
917 
918 	dprintk("%s:\n", __func__);
919 
920 	stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
921 	stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
922 	msleep(350);
923 }
924 #endif
925 static int stv0367ter_standby(struct dvb_frontend *fe, u8 standby_on)
926 {
927 	struct stv0367_state *state = fe->demodulator_priv;
928 
929 	dprintk("%s:\n", __func__);
930 
931 	if (standby_on) {
932 		stv0367_writebits(state, F367TER_STDBY, 1);
933 		stv0367_writebits(state, F367TER_STDBY_FEC, 1);
934 		stv0367_writebits(state, F367TER_STDBY_CORE, 1);
935 	} else {
936 		stv0367_writebits(state, F367TER_STDBY, 0);
937 		stv0367_writebits(state, F367TER_STDBY_FEC, 0);
938 		stv0367_writebits(state, F367TER_STDBY_CORE, 0);
939 	}
940 
941 	return 0;
942 }
943 
944 static int stv0367ter_sleep(struct dvb_frontend *fe)
945 {
946 	return stv0367ter_standby(fe, 1);
947 }
948 
949 static int stv0367ter_init(struct dvb_frontend *fe)
950 {
951 	struct stv0367_state *state = fe->demodulator_priv;
952 	struct stv0367ter_state *ter_state = state->ter_state;
953 
954 	dprintk("%s:\n", __func__);
955 
956 	ter_state->pBER = 0;
957 
958 	stv0367_write_table(state,
959 		stv0367_deftabs[state->deftabs][STV0367_TAB_TER]);
960 
961 	stv0367_pll_setup(state, STV0367_ICSPEED_53125, state->config->xtal);
962 
963 	stv0367_writereg(state, R367TER_I2CRPT, 0xa0);
964 	stv0367_writereg(state, R367TER_ANACTRL, 0x00);
965 
966 	/*Set TS1 and TS2 to serial or parallel mode */
967 	stv0367ter_set_ts_mode(state, state->config->ts_mode);
968 	stv0367ter_set_clk_pol(state, state->config->clk_pol);
969 
970 	state->chip_id = stv0367_readreg(state, R367TER_ID);
971 	ter_state->first_lock = 0;
972 	ter_state->unlock_counter = 2;
973 
974 	return 0;
975 }
976 
977 static int stv0367ter_algo(struct dvb_frontend *fe)
978 {
979 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
980 	struct stv0367_state *state = fe->demodulator_priv;
981 	struct stv0367ter_state *ter_state = state->ter_state;
982 	int offset = 0, tempo = 0;
983 	u8 u_var;
984 	u8 /*constell,*/ counter;
985 	s8 step;
986 	s32 timing_offset = 0;
987 	u32 trl_nomrate = 0, InternalFreq = 0, temp = 0, ifkhz = 0;
988 
989 	dprintk("%s:\n", __func__);
990 
991 	stv0367_get_if_khz(state, &ifkhz);
992 
993 	ter_state->frequency = p->frequency;
994 	ter_state->force = FE_TER_FORCENONE
995 			+ stv0367_readbits(state, F367TER_FORCE) * 2;
996 	ter_state->if_iq_mode = state->config->if_iq_mode;
997 	switch (state->config->if_iq_mode) {
998 	case FE_TER_NORMAL_IF_TUNER:  /* Normal IF mode */
999 		dprintk("ALGO: FE_TER_NORMAL_IF_TUNER selected\n");
1000 		stv0367_writebits(state, F367TER_TUNER_BB, 0);
1001 		stv0367_writebits(state, F367TER_LONGPATH_IF, 0);
1002 		stv0367_writebits(state, F367TER_DEMUX_SWAP, 0);
1003 		break;
1004 	case FE_TER_LONGPATH_IF_TUNER:  /* Long IF mode */
1005 		dprintk("ALGO: FE_TER_LONGPATH_IF_TUNER selected\n");
1006 		stv0367_writebits(state, F367TER_TUNER_BB, 0);
1007 		stv0367_writebits(state, F367TER_LONGPATH_IF, 1);
1008 		stv0367_writebits(state, F367TER_DEMUX_SWAP, 1);
1009 		break;
1010 	case FE_TER_IQ_TUNER:  /* IQ mode */
1011 		dprintk("ALGO: FE_TER_IQ_TUNER selected\n");
1012 		stv0367_writebits(state, F367TER_TUNER_BB, 1);
1013 		stv0367_writebits(state, F367TER_PPM_INVSEL, 0);
1014 		break;
1015 	default:
1016 		printk(KERN_ERR "ALGO: wrong TUNER type selected\n");
1017 		return -EINVAL;
1018 	}
1019 
1020 	usleep_range(5000, 7000);
1021 
1022 	switch (p->inversion) {
1023 	case INVERSION_AUTO:
1024 	default:
1025 		dprintk("%s: inversion AUTO\n", __func__);
1026 		if (ter_state->if_iq_mode == FE_TER_IQ_TUNER)
1027 			stv0367_writebits(state, F367TER_IQ_INVERT,
1028 						ter_state->sense);
1029 		else
1030 			stv0367_writebits(state, F367TER_INV_SPECTR,
1031 						ter_state->sense);
1032 
1033 		break;
1034 	case INVERSION_ON:
1035 	case INVERSION_OFF:
1036 		if (ter_state->if_iq_mode == FE_TER_IQ_TUNER)
1037 			stv0367_writebits(state, F367TER_IQ_INVERT,
1038 						p->inversion);
1039 		else
1040 			stv0367_writebits(state, F367TER_INV_SPECTR,
1041 						p->inversion);
1042 
1043 		break;
1044 	}
1045 
1046 	if ((ter_state->if_iq_mode != FE_TER_NORMAL_IF_TUNER) &&
1047 				(ter_state->pBW != ter_state->bw)) {
1048 		stv0367ter_agc_iir_lock_detect_set(state);
1049 
1050 		/*set fine agc target to 180 for LPIF or IQ mode*/
1051 		/* set Q_AGCTarget */
1052 		stv0367_writebits(state, F367TER_SEL_IQNTAR, 1);
1053 		stv0367_writebits(state, F367TER_AUT_AGC_TARGET_MSB, 0xB);
1054 		/*stv0367_writebits(state,AUT_AGC_TARGET_LSB,0x04); */
1055 
1056 		/* set Q_AGCTarget */
1057 		stv0367_writebits(state, F367TER_SEL_IQNTAR, 0);
1058 		stv0367_writebits(state, F367TER_AUT_AGC_TARGET_MSB, 0xB);
1059 		/*stv0367_writebits(state,AUT_AGC_TARGET_LSB,0x04); */
1060 
1061 		if (!stv0367_iir_filt_init(state, ter_state->bw,
1062 						state->config->xtal))
1063 			return -EINVAL;
1064 		/*set IIR filter once for 6,7 or 8MHz BW*/
1065 		ter_state->pBW = ter_state->bw;
1066 
1067 		stv0367ter_agc_iir_rst(state);
1068 	}
1069 
1070 	if (ter_state->hierarchy == FE_TER_HIER_LOW_PRIO)
1071 		stv0367_writebits(state, F367TER_BDI_LPSEL, 0x01);
1072 	else
1073 		stv0367_writebits(state, F367TER_BDI_LPSEL, 0x00);
1074 
1075 	InternalFreq = stv0367ter_get_mclk(state, state->config->xtal) / 1000;
1076 	temp = (int)
1077 		((((ter_state->bw * 64 * (1 << 15) * 100)
1078 						/ (InternalFreq)) * 10) / 7);
1079 
1080 	stv0367_writebits(state, F367TER_TRL_NOMRATE_LSB, temp % 2);
1081 	temp = temp / 2;
1082 	stv0367_writebits(state, F367TER_TRL_NOMRATE_HI, temp / 256);
1083 	stv0367_writebits(state, F367TER_TRL_NOMRATE_LO, temp % 256);
1084 
1085 	temp = stv0367_readbits(state, F367TER_TRL_NOMRATE_HI) * 512 +
1086 			stv0367_readbits(state, F367TER_TRL_NOMRATE_LO) * 2 +
1087 			stv0367_readbits(state, F367TER_TRL_NOMRATE_LSB);
1088 	temp = (int)(((1 << 17) * ter_state->bw * 1000) / (7 * (InternalFreq)));
1089 	stv0367_writebits(state, F367TER_GAIN_SRC_HI, temp / 256);
1090 	stv0367_writebits(state, F367TER_GAIN_SRC_LO, temp % 256);
1091 	temp = stv0367_readbits(state, F367TER_GAIN_SRC_HI) * 256 +
1092 			stv0367_readbits(state, F367TER_GAIN_SRC_LO);
1093 
1094 	temp = (int)
1095 		((InternalFreq - ifkhz) * (1 << 16) / (InternalFreq));
1096 
1097 	dprintk("DEROT temp=0x%x\n", temp);
1098 	stv0367_writebits(state, F367TER_INC_DEROT_HI, temp / 256);
1099 	stv0367_writebits(state, F367TER_INC_DEROT_LO, temp % 256);
1100 
1101 	ter_state->echo_pos = 0;
1102 	ter_state->ucblocks = 0; /* liplianin */
1103 	ter_state->pBER = 0; /* liplianin */
1104 	stv0367_writebits(state, F367TER_LONG_ECHO, ter_state->echo_pos);
1105 
1106 	if (stv0367ter_lock_algo(state) != FE_TER_LOCKOK)
1107 		return 0;
1108 
1109 	ter_state->state = FE_TER_LOCKOK;
1110 
1111 	ter_state->mode = stv0367_readbits(state, F367TER_SYR_MODE);
1112 	ter_state->guard = stv0367_readbits(state, F367TER_SYR_GUARD);
1113 
1114 	ter_state->first_lock = 1; /* we know sense now :) */
1115 
1116 	ter_state->agc_val =
1117 			(stv0367_readbits(state, F367TER_AGC1_VAL_LO) << 16) +
1118 			(stv0367_readbits(state, F367TER_AGC1_VAL_HI) << 24) +
1119 			stv0367_readbits(state, F367TER_AGC2_VAL_LO) +
1120 			(stv0367_readbits(state, F367TER_AGC2_VAL_HI) << 8);
1121 
1122 	/* Carrier offset calculation */
1123 	stv0367_writebits(state, F367TER_FREEZE, 1);
1124 	offset = (stv0367_readbits(state, F367TER_CRL_FOFFSET_VHI) << 16) ;
1125 	offset += (stv0367_readbits(state, F367TER_CRL_FOFFSET_HI) << 8);
1126 	offset += (stv0367_readbits(state, F367TER_CRL_FOFFSET_LO));
1127 	stv0367_writebits(state, F367TER_FREEZE, 0);
1128 	if (offset > 8388607)
1129 		offset -= 16777216;
1130 
1131 	offset = offset * 2 / 16384;
1132 
1133 	if (ter_state->mode == FE_TER_MODE_2K)
1134 		offset = (offset * 4464) / 1000;/*** 1 FFT BIN=4.464khz***/
1135 	else if (ter_state->mode == FE_TER_MODE_4K)
1136 		offset = (offset * 223) / 100;/*** 1 FFT BIN=2.23khz***/
1137 	else  if (ter_state->mode == FE_TER_MODE_8K)
1138 		offset = (offset * 111) / 100;/*** 1 FFT BIN=1.1khz***/
1139 
1140 	if (stv0367_readbits(state, F367TER_PPM_INVSEL) == 1) {
1141 		if ((stv0367_readbits(state, F367TER_INV_SPECTR) ==
1142 				(stv0367_readbits(state,
1143 					F367TER_STATUS_INV_SPECRUM) == 1)))
1144 			offset = offset * -1;
1145 	}
1146 
1147 	if (ter_state->bw == 6)
1148 		offset = (offset * 6) / 8;
1149 	else if (ter_state->bw == 7)
1150 		offset = (offset * 7) / 8;
1151 
1152 	ter_state->frequency += offset;
1153 
1154 	tempo = 10;  /* exit even if timing_offset stays null */
1155 	while ((timing_offset == 0) && (tempo > 0)) {
1156 		usleep_range(10000, 20000);	/*was 20ms  */
1157 		/* fine tuning of timing offset if required */
1158 		timing_offset = stv0367_readbits(state, F367TER_TRL_TOFFSET_LO)
1159 				+ 256 * stv0367_readbits(state,
1160 							F367TER_TRL_TOFFSET_HI);
1161 		if (timing_offset >= 32768)
1162 			timing_offset -= 65536;
1163 		trl_nomrate = (512 * stv0367_readbits(state,
1164 							F367TER_TRL_NOMRATE_HI)
1165 			+ stv0367_readbits(state, F367TER_TRL_NOMRATE_LO) * 2
1166 			+ stv0367_readbits(state, F367TER_TRL_NOMRATE_LSB));
1167 
1168 		timing_offset = ((signed)(1000000 / trl_nomrate) *
1169 							timing_offset) / 2048;
1170 		tempo--;
1171 	}
1172 
1173 	if (timing_offset <= 0) {
1174 		timing_offset = (timing_offset - 11) / 22;
1175 		step = -1;
1176 	} else {
1177 		timing_offset = (timing_offset + 11) / 22;
1178 		step = 1;
1179 	}
1180 
1181 	for (counter = 0; counter < abs(timing_offset); counter++) {
1182 		trl_nomrate += step;
1183 		stv0367_writebits(state, F367TER_TRL_NOMRATE_LSB,
1184 						trl_nomrate % 2);
1185 		stv0367_writebits(state, F367TER_TRL_NOMRATE_LO,
1186 						trl_nomrate / 2);
1187 		usleep_range(1000, 2000);
1188 	}
1189 
1190 	usleep_range(5000, 6000);
1191 	/* unlocks could happen in case of trl centring big step,
1192 	then a core off/on restarts demod */
1193 	u_var = stv0367_readbits(state, F367TER_LK);
1194 
1195 	if (!u_var) {
1196 		stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
1197 		msleep(20);
1198 		stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
1199 	}
1200 
1201 	return 0;
1202 }
1203 
1204 static int stv0367ter_set_frontend(struct dvb_frontend *fe)
1205 {
1206 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1207 	struct stv0367_state *state = fe->demodulator_priv;
1208 	struct stv0367ter_state *ter_state = state->ter_state;
1209 
1210 	/*u8 trials[2]; */
1211 	s8 num_trials, index;
1212 	u8 SenseTrials[] = { INVERSION_ON, INVERSION_OFF };
1213 
1214 	if (state->reinit_on_setfrontend)
1215 		stv0367ter_init(fe);
1216 
1217 	if (fe->ops.tuner_ops.set_params) {
1218 		if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
1219 			fe->ops.i2c_gate_ctrl(fe, 1);
1220 		fe->ops.tuner_ops.set_params(fe);
1221 		if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
1222 			fe->ops.i2c_gate_ctrl(fe, 0);
1223 	}
1224 
1225 	switch (p->transmission_mode) {
1226 	default:
1227 	case TRANSMISSION_MODE_AUTO:
1228 	case TRANSMISSION_MODE_2K:
1229 		ter_state->mode = FE_TER_MODE_2K;
1230 		break;
1231 /*	case TRANSMISSION_MODE_4K:
1232 		pLook.mode = FE_TER_MODE_4K;
1233 		break;*/
1234 	case TRANSMISSION_MODE_8K:
1235 		ter_state->mode = FE_TER_MODE_8K;
1236 		break;
1237 	}
1238 
1239 	switch (p->guard_interval) {
1240 	default:
1241 	case GUARD_INTERVAL_1_32:
1242 	case GUARD_INTERVAL_1_16:
1243 	case GUARD_INTERVAL_1_8:
1244 	case GUARD_INTERVAL_1_4:
1245 		ter_state->guard = p->guard_interval;
1246 		break;
1247 	case GUARD_INTERVAL_AUTO:
1248 		ter_state->guard = GUARD_INTERVAL_1_32;
1249 		break;
1250 	}
1251 
1252 	switch (p->bandwidth_hz) {
1253 	case 6000000:
1254 		ter_state->bw = FE_TER_CHAN_BW_6M;
1255 		break;
1256 	case 7000000:
1257 		ter_state->bw = FE_TER_CHAN_BW_7M;
1258 		break;
1259 	case 8000000:
1260 	default:
1261 		ter_state->bw = FE_TER_CHAN_BW_8M;
1262 	}
1263 
1264 	ter_state->hierarchy = FE_TER_HIER_NONE;
1265 
1266 	switch (p->inversion) {
1267 	case INVERSION_OFF:
1268 	case INVERSION_ON:
1269 		num_trials = 1;
1270 		break;
1271 	default:
1272 		num_trials = 2;
1273 		if (ter_state->first_lock)
1274 			num_trials = 1;
1275 		break;
1276 	}
1277 
1278 	ter_state->state = FE_TER_NOLOCK;
1279 	index = 0;
1280 
1281 	while (((index) < num_trials) && (ter_state->state != FE_TER_LOCKOK)) {
1282 		if (!ter_state->first_lock) {
1283 			if (p->inversion == INVERSION_AUTO)
1284 				ter_state->sense = SenseTrials[index];
1285 
1286 		}
1287 		stv0367ter_algo(fe);
1288 
1289 		if ((ter_state->state == FE_TER_LOCKOK) &&
1290 				(p->inversion == INVERSION_AUTO) &&
1291 								(index == 1)) {
1292 			/* invert spectrum sense */
1293 			SenseTrials[index] = SenseTrials[0];
1294 			SenseTrials[(index + 1) % 2] = (SenseTrials[1] + 1) % 2;
1295 		}
1296 
1297 		index++;
1298 	}
1299 
1300 	return 0;
1301 }
1302 
1303 static int stv0367ter_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1304 {
1305 	struct stv0367_state *state = fe->demodulator_priv;
1306 	struct stv0367ter_state *ter_state = state->ter_state;
1307 	u32 errs = 0;
1308 
1309 	/*wait for counting completion*/
1310 	if (stv0367_readbits(state, F367TER_SFERRC_OLDVALUE) == 0) {
1311 		errs =
1312 			((u32)stv0367_readbits(state, F367TER_ERR_CNT1)
1313 			* (1 << 16))
1314 			+ ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_HI)
1315 			* (1 << 8))
1316 			+ ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_LO));
1317 		ter_state->ucblocks = errs;
1318 	}
1319 
1320 	(*ucblocks) = ter_state->ucblocks;
1321 
1322 	return 0;
1323 }
1324 
1325 static int stv0367ter_get_frontend(struct dvb_frontend *fe,
1326 				   struct dtv_frontend_properties *p)
1327 {
1328 	struct stv0367_state *state = fe->demodulator_priv;
1329 	struct stv0367ter_state *ter_state = state->ter_state;
1330 	enum stv0367_ter_mode mode;
1331 	int constell = 0,/* snr = 0,*/ Data = 0;
1332 
1333 	p->frequency = stv0367_get_tuner_freq(fe);
1334 	if ((int)p->frequency < 0)
1335 		p->frequency = -p->frequency;
1336 
1337 	constell = stv0367_readbits(state, F367TER_TPS_CONST);
1338 	if (constell == 0)
1339 		p->modulation = QPSK;
1340 	else if (constell == 1)
1341 		p->modulation = QAM_16;
1342 	else
1343 		p->modulation = QAM_64;
1344 
1345 	p->inversion = stv0367_readbits(state, F367TER_INV_SPECTR);
1346 
1347 	/* Get the Hierarchical mode */
1348 	Data = stv0367_readbits(state, F367TER_TPS_HIERMODE);
1349 
1350 	switch (Data) {
1351 	case 0:
1352 		p->hierarchy = HIERARCHY_NONE;
1353 		break;
1354 	case 1:
1355 		p->hierarchy = HIERARCHY_1;
1356 		break;
1357 	case 2:
1358 		p->hierarchy = HIERARCHY_2;
1359 		break;
1360 	case 3:
1361 		p->hierarchy = HIERARCHY_4;
1362 		break;
1363 	default:
1364 		p->hierarchy = HIERARCHY_AUTO;
1365 		break; /* error */
1366 	}
1367 
1368 	/* Get the FEC Rate */
1369 	if (ter_state->hierarchy == FE_TER_HIER_LOW_PRIO)
1370 		Data = stv0367_readbits(state, F367TER_TPS_LPCODE);
1371 	else
1372 		Data = stv0367_readbits(state, F367TER_TPS_HPCODE);
1373 
1374 	switch (Data) {
1375 	case 0:
1376 		p->code_rate_HP = FEC_1_2;
1377 		break;
1378 	case 1:
1379 		p->code_rate_HP = FEC_2_3;
1380 		break;
1381 	case 2:
1382 		p->code_rate_HP = FEC_3_4;
1383 		break;
1384 	case 3:
1385 		p->code_rate_HP = FEC_5_6;
1386 		break;
1387 	case 4:
1388 		p->code_rate_HP = FEC_7_8;
1389 		break;
1390 	default:
1391 		p->code_rate_HP = FEC_AUTO;
1392 		break; /* error */
1393 	}
1394 
1395 	mode = stv0367_readbits(state, F367TER_SYR_MODE);
1396 
1397 	switch (mode) {
1398 	case FE_TER_MODE_2K:
1399 		p->transmission_mode = TRANSMISSION_MODE_2K;
1400 		break;
1401 /*	case FE_TER_MODE_4K:
1402 		p->transmission_mode = TRANSMISSION_MODE_4K;
1403 		break;*/
1404 	case FE_TER_MODE_8K:
1405 		p->transmission_mode = TRANSMISSION_MODE_8K;
1406 		break;
1407 	default:
1408 		p->transmission_mode = TRANSMISSION_MODE_AUTO;
1409 	}
1410 
1411 	p->guard_interval = stv0367_readbits(state, F367TER_SYR_GUARD);
1412 
1413 	return 0;
1414 }
1415 
1416 static u32 stv0367ter_snr_readreg(struct dvb_frontend *fe)
1417 {
1418 	struct stv0367_state *state = fe->demodulator_priv;
1419 	u32 snru32 = 0;
1420 	int cpt = 0;
1421 	u8 cut = stv0367_readbits(state, F367TER_IDENTIFICATIONREG);
1422 
1423 	while (cpt < 10) {
1424 		usleep_range(2000, 3000);
1425 		if (cut == 0x50) /*cut 1.0 cut 1.1*/
1426 			snru32 += stv0367_readbits(state, F367TER_CHCSNR) / 4;
1427 		else /*cu2.0*/
1428 			snru32 += 125 * stv0367_readbits(state, F367TER_CHCSNR);
1429 
1430 		cpt++;
1431 	}
1432 	snru32 /= 10;/*average on 10 values*/
1433 
1434 	return snru32;
1435 }
1436 
1437 static int stv0367ter_read_snr(struct dvb_frontend *fe, u16 *snr)
1438 {
1439 	u32 snrval = stv0367ter_snr_readreg(fe);
1440 
1441 	*snr = snrval / 1000;
1442 
1443 	return 0;
1444 }
1445 
1446 #if 0
1447 static int stv0367ter_status(struct dvb_frontend *fe)
1448 {
1449 
1450 	struct stv0367_state *state = fe->demodulator_priv;
1451 	struct stv0367ter_state *ter_state = state->ter_state;
1452 	int locked = FALSE;
1453 
1454 	locked = (stv0367_readbits(state, F367TER_LK));
1455 	if (!locked)
1456 		ter_state->unlock_counter += 1;
1457 	else
1458 		ter_state->unlock_counter = 0;
1459 
1460 	if (ter_state->unlock_counter > 2) {
1461 		if (!stv0367_readbits(state, F367TER_TPS_LOCK) ||
1462 				(!stv0367_readbits(state, F367TER_LK))) {
1463 			stv0367_writebits(state, F367TER_CORE_ACTIVE, 0);
1464 			usleep_range(2000, 3000);
1465 			stv0367_writebits(state, F367TER_CORE_ACTIVE, 1);
1466 			msleep(350);
1467 			locked = (stv0367_readbits(state, F367TER_TPS_LOCK)) &&
1468 					(stv0367_readbits(state, F367TER_LK));
1469 		}
1470 
1471 	}
1472 
1473 	return locked;
1474 }
1475 #endif
1476 static int stv0367ter_read_status(struct dvb_frontend *fe,
1477 				  enum fe_status *status)
1478 {
1479 	struct stv0367_state *state = fe->demodulator_priv;
1480 
1481 	dprintk("%s:\n", __func__);
1482 
1483 	*status = 0;
1484 
1485 	if (stv0367_readbits(state, F367TER_LK)) {
1486 		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI
1487 			  | FE_HAS_SYNC | FE_HAS_LOCK;
1488 		dprintk("%s: stv0367 has locked\n", __func__);
1489 	}
1490 
1491 	return 0;
1492 }
1493 
1494 static int stv0367ter_read_ber(struct dvb_frontend *fe, u32 *ber)
1495 {
1496 	struct stv0367_state *state = fe->demodulator_priv;
1497 	struct stv0367ter_state *ter_state = state->ter_state;
1498 	u32 Errors = 0, tber = 0, temporary = 0;
1499 	int abc = 0, def = 0;
1500 
1501 
1502 	/*wait for counting completion*/
1503 	if (stv0367_readbits(state, F367TER_SFERRC_OLDVALUE) == 0)
1504 		Errors = ((u32)stv0367_readbits(state, F367TER_SFEC_ERR_CNT)
1505 			* (1 << 16))
1506 			+ ((u32)stv0367_readbits(state, F367TER_SFEC_ERR_CNT_HI)
1507 			* (1 << 8))
1508 			+ ((u32)stv0367_readbits(state,
1509 						F367TER_SFEC_ERR_CNT_LO));
1510 	/*measurement not completed, load previous value*/
1511 	else {
1512 		tber = ter_state->pBER;
1513 		return 0;
1514 	}
1515 
1516 	abc = stv0367_readbits(state, F367TER_SFEC_ERR_SOURCE);
1517 	def = stv0367_readbits(state, F367TER_SFEC_NUM_EVENT);
1518 
1519 	if (Errors == 0) {
1520 		tber = 0;
1521 	} else if (abc == 0x7) {
1522 		if (Errors <= 4) {
1523 			temporary = (Errors * 1000000000) / (8 * (1 << 14));
1524 		} else if (Errors <= 42) {
1525 			temporary = (Errors * 100000000) / (8 * (1 << 14));
1526 			temporary = temporary * 10;
1527 		} else if (Errors <= 429) {
1528 			temporary = (Errors * 10000000) / (8 * (1 << 14));
1529 			temporary = temporary * 100;
1530 		} else if (Errors <= 4294) {
1531 			temporary = (Errors * 1000000) / (8 * (1 << 14));
1532 			temporary = temporary * 1000;
1533 		} else if (Errors <= 42949) {
1534 			temporary = (Errors * 100000) / (8 * (1 << 14));
1535 			temporary = temporary * 10000;
1536 		} else if (Errors <= 429496) {
1537 			temporary = (Errors * 10000) / (8 * (1 << 14));
1538 			temporary = temporary * 100000;
1539 		} else { /*if (Errors<4294967) 2^22 max error*/
1540 			temporary = (Errors * 1000) / (8 * (1 << 14));
1541 			temporary = temporary * 100000;	/* still to *10 */
1542 		}
1543 
1544 		/* Byte error*/
1545 		if (def == 2)
1546 			/*tber=Errors/(8*(1 <<14));*/
1547 			tber = temporary;
1548 		else if (def == 3)
1549 			/*tber=Errors/(8*(1 <<16));*/
1550 			tber = temporary / 4;
1551 		else if (def == 4)
1552 			/*tber=Errors/(8*(1 <<18));*/
1553 			tber = temporary / 16;
1554 		else if (def == 5)
1555 			/*tber=Errors/(8*(1 <<20));*/
1556 			tber = temporary / 64;
1557 		else if (def == 6)
1558 			/*tber=Errors/(8*(1 <<22));*/
1559 			tber = temporary / 256;
1560 		else
1561 			/* should not pass here*/
1562 			tber = 0;
1563 
1564 		if ((Errors < 4294967) && (Errors > 429496))
1565 			tber *= 10;
1566 
1567 	}
1568 
1569 	/* save actual value */
1570 	ter_state->pBER = tber;
1571 
1572 	(*ber) = tber;
1573 
1574 	return 0;
1575 }
1576 #if 0
1577 static u32 stv0367ter_get_per(struct stv0367_state *state)
1578 {
1579 	struct stv0367ter_state *ter_state = state->ter_state;
1580 	u32 Errors = 0, Per = 0, temporary = 0;
1581 	int abc = 0, def = 0, cpt = 0;
1582 
1583 	while (((stv0367_readbits(state, F367TER_SFERRC_OLDVALUE) == 1) &&
1584 			(cpt < 400)) || ((Errors == 0) && (cpt < 400))) {
1585 		usleep_range(1000, 2000);
1586 		Errors = ((u32)stv0367_readbits(state, F367TER_ERR_CNT1)
1587 			* (1 << 16))
1588 			+ ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_HI)
1589 			* (1 << 8))
1590 			+ ((u32)stv0367_readbits(state, F367TER_ERR_CNT1_LO));
1591 		cpt++;
1592 	}
1593 	abc = stv0367_readbits(state, F367TER_ERR_SRC1);
1594 	def = stv0367_readbits(state, F367TER_NUM_EVT1);
1595 
1596 	if (Errors == 0)
1597 		Per = 0;
1598 	else if (abc == 0x9) {
1599 		if (Errors <= 4) {
1600 			temporary = (Errors * 1000000000) / (8 * (1 << 8));
1601 		} else if (Errors <= 42) {
1602 			temporary = (Errors * 100000000) / (8 * (1 << 8));
1603 			temporary = temporary * 10;
1604 		} else if (Errors <= 429) {
1605 			temporary = (Errors * 10000000) / (8 * (1 << 8));
1606 			temporary = temporary * 100;
1607 		} else if (Errors <= 4294) {
1608 			temporary = (Errors * 1000000) / (8 * (1 << 8));
1609 			temporary = temporary * 1000;
1610 		} else if (Errors <= 42949) {
1611 			temporary = (Errors * 100000) / (8 * (1 << 8));
1612 			temporary = temporary * 10000;
1613 		} else { /*if(Errors<=429496)  2^16 errors max*/
1614 			temporary = (Errors * 10000) / (8 * (1 << 8));
1615 			temporary = temporary * 100000;
1616 		}
1617 
1618 		/* pkt error*/
1619 		if (def == 2)
1620 			/*Per=Errors/(1 << 8);*/
1621 			Per = temporary;
1622 		else if (def == 3)
1623 			/*Per=Errors/(1 << 10);*/
1624 			Per = temporary / 4;
1625 		else if (def == 4)
1626 			/*Per=Errors/(1 << 12);*/
1627 			Per = temporary / 16;
1628 		else if (def == 5)
1629 			/*Per=Errors/(1 << 14);*/
1630 			Per = temporary / 64;
1631 		else if (def == 6)
1632 			/*Per=Errors/(1 << 16);*/
1633 			Per = temporary / 256;
1634 		else
1635 			Per = 0;
1636 
1637 	}
1638 	/* save actual value */
1639 	ter_state->pPER = Per;
1640 
1641 	return Per;
1642 }
1643 #endif
1644 static int stv0367_get_tune_settings(struct dvb_frontend *fe,
1645 					struct dvb_frontend_tune_settings
1646 					*fe_tune_settings)
1647 {
1648 	fe_tune_settings->min_delay_ms = 1000;
1649 	fe_tune_settings->step_size = 0;
1650 	fe_tune_settings->max_drift = 0;
1651 
1652 	return 0;
1653 }
1654 
1655 static void stv0367_release(struct dvb_frontend *fe)
1656 {
1657 	struct stv0367_state *state = fe->demodulator_priv;
1658 
1659 	kfree(state->ter_state);
1660 	kfree(state->cab_state);
1661 	kfree(state);
1662 }
1663 
1664 static const struct dvb_frontend_ops stv0367ter_ops = {
1665 	.delsys = { SYS_DVBT },
1666 	.info = {
1667 		.name			= "ST STV0367 DVB-T",
1668 		.frequency_min_hz	=  47 * MHz,
1669 		.frequency_max_hz	= 862 * MHz,
1670 		.frequency_stepsize_hz	= 15625,
1671 		.caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
1672 			FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
1673 			FE_CAN_FEC_AUTO |
1674 			FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
1675 			FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_QAM_AUTO |
1676 			FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_RECOVER |
1677 			FE_CAN_INVERSION_AUTO |
1678 			FE_CAN_MUTE_TS
1679 	},
1680 	.release = stv0367_release,
1681 	.init = stv0367ter_init,
1682 	.sleep = stv0367ter_sleep,
1683 	.i2c_gate_ctrl = stv0367ter_gate_ctrl,
1684 	.set_frontend = stv0367ter_set_frontend,
1685 	.get_frontend = stv0367ter_get_frontend,
1686 	.get_tune_settings = stv0367_get_tune_settings,
1687 	.read_status = stv0367ter_read_status,
1688 	.read_ber = stv0367ter_read_ber,/* too slow */
1689 /*	.read_signal_strength = stv0367_read_signal_strength,*/
1690 	.read_snr = stv0367ter_read_snr,
1691 	.read_ucblocks = stv0367ter_read_ucblocks,
1692 };
1693 
1694 struct dvb_frontend *stv0367ter_attach(const struct stv0367_config *config,
1695 				   struct i2c_adapter *i2c)
1696 {
1697 	struct stv0367_state *state = NULL;
1698 	struct stv0367ter_state *ter_state = NULL;
1699 
1700 	/* allocate memory for the internal state */
1701 	state = kzalloc(sizeof(struct stv0367_state), GFP_KERNEL);
1702 	if (state == NULL)
1703 		goto error;
1704 	ter_state = kzalloc(sizeof(struct stv0367ter_state), GFP_KERNEL);
1705 	if (ter_state == NULL)
1706 		goto error;
1707 
1708 	/* setup the state */
1709 	state->i2c = i2c;
1710 	state->config = config;
1711 	state->ter_state = ter_state;
1712 	state->fe.ops = stv0367ter_ops;
1713 	state->fe.demodulator_priv = state;
1714 	state->chip_id = stv0367_readreg(state, 0xf000);
1715 
1716 	/* demod operation options */
1717 	state->use_i2c_gatectrl = 1;
1718 	state->deftabs = STV0367_DEFTAB_GENERIC;
1719 	state->reinit_on_setfrontend = 1;
1720 	state->auto_if_khz = 0;
1721 
1722 	dprintk("%s: chip_id = 0x%x\n", __func__, state->chip_id);
1723 
1724 	/* check if the demod is there */
1725 	if ((state->chip_id != 0x50) && (state->chip_id != 0x60))
1726 		goto error;
1727 
1728 	return &state->fe;
1729 
1730 error:
1731 	kfree(ter_state);
1732 	kfree(state);
1733 	return NULL;
1734 }
1735 EXPORT_SYMBOL_GPL(stv0367ter_attach);
1736 
1737 static int stv0367cab_gate_ctrl(struct dvb_frontend *fe, int enable)
1738 {
1739 	struct stv0367_state *state = fe->demodulator_priv;
1740 
1741 	dprintk("%s:\n", __func__);
1742 
1743 	stv0367_writebits(state, F367CAB_I2CT_ON, (enable > 0) ? 1 : 0);
1744 
1745 	return 0;
1746 }
1747 
1748 static u32 stv0367cab_get_mclk(struct dvb_frontend *fe, u32 ExtClk_Hz)
1749 {
1750 	struct stv0367_state *state = fe->demodulator_priv;
1751 	u32 mclk_Hz = 0;/* master clock frequency (Hz) */
1752 	u32 M, N, P;
1753 
1754 
1755 	if (stv0367_readbits(state, F367CAB_BYPASS_PLLXN) == 0) {
1756 		N = (u32)stv0367_readbits(state, F367CAB_PLL_NDIV);
1757 		if (N == 0)
1758 			N = N + 1;
1759 
1760 		M = (u32)stv0367_readbits(state, F367CAB_PLL_MDIV);
1761 		if (M == 0)
1762 			M = M + 1;
1763 
1764 		P = (u32)stv0367_readbits(state, F367CAB_PLL_PDIV);
1765 
1766 		if (P > 5)
1767 			P = 5;
1768 
1769 		mclk_Hz = ((ExtClk_Hz / 2) * N) / (M * (1 << P));
1770 		dprintk("stv0367cab_get_mclk BYPASS_PLLXN mclk_Hz=%d\n",
1771 								mclk_Hz);
1772 	} else
1773 		mclk_Hz = ExtClk_Hz;
1774 
1775 	dprintk("stv0367cab_get_mclk final mclk_Hz=%d\n", mclk_Hz);
1776 
1777 	return mclk_Hz;
1778 }
1779 
1780 static u32 stv0367cab_get_adc_freq(struct dvb_frontend *fe, u32 ExtClk_Hz)
1781 {
1782 	return stv0367cab_get_mclk(fe, ExtClk_Hz);
1783 }
1784 
1785 static enum stv0367cab_mod stv0367cab_SetQamSize(struct stv0367_state *state,
1786 						 u32 SymbolRate,
1787 						 enum stv0367cab_mod QAMSize)
1788 {
1789 	/* Set QAM size */
1790 	stv0367_writebits(state, F367CAB_QAM_MODE, QAMSize);
1791 
1792 	/* Set Registers settings specific to the QAM size */
1793 	switch (QAMSize) {
1794 	case FE_CAB_MOD_QAM4:
1795 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1796 		break;
1797 	case FE_CAB_MOD_QAM16:
1798 		stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x64);
1799 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1800 		stv0367_writereg(state, R367CAB_FSM_STATE, 0x90);
1801 		stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1802 		stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1803 		stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x95);
1804 		stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x40);
1805 		stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0x8a);
1806 		break;
1807 	case FE_CAB_MOD_QAM32:
1808 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1809 		stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x6e);
1810 		stv0367_writereg(state, R367CAB_FSM_STATE, 0xb0);
1811 		stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1812 		stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xb7);
1813 		stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x9d);
1814 		stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x7f);
1815 		stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0xa7);
1816 		break;
1817 	case FE_CAB_MOD_QAM64:
1818 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x82);
1819 		stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x5a);
1820 		if (SymbolRate > 4500000) {
1821 			stv0367_writereg(state, R367CAB_FSM_STATE, 0xb0);
1822 			stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1823 			stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa5);
1824 		} else if (SymbolRate > 2500000) {
1825 			stv0367_writereg(state, R367CAB_FSM_STATE, 0xa0);
1826 			stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1827 			stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa6);
1828 		} else {
1829 			stv0367_writereg(state, R367CAB_FSM_STATE, 0xa0);
1830 			stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xd1);
1831 			stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1832 		}
1833 		stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x95);
1834 		stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x40);
1835 		stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0x99);
1836 		break;
1837 	case FE_CAB_MOD_QAM128:
1838 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1839 		stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x76);
1840 		stv0367_writereg(state, R367CAB_FSM_STATE, 0x90);
1841 		stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xb1);
1842 		if (SymbolRate > 4500000)
1843 			stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1844 		else if (SymbolRate > 2500000)
1845 			stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa6);
1846 		else
1847 			stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0x97);
1848 
1849 		stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x8e);
1850 		stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x7f);
1851 		stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0xa7);
1852 		break;
1853 	case FE_CAB_MOD_QAM256:
1854 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x94);
1855 		stv0367_writereg(state, R367CAB_AGC_PWR_REF_L, 0x5a);
1856 		stv0367_writereg(state, R367CAB_FSM_STATE, 0xa0);
1857 		if (SymbolRate > 4500000)
1858 			stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1859 		else if (SymbolRate > 2500000)
1860 			stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xc1);
1861 		else
1862 			stv0367_writereg(state, R367CAB_EQU_CTR_LPF_GAIN, 0xd1);
1863 
1864 		stv0367_writereg(state, R367CAB_EQU_CRL_LPF_GAIN, 0xa7);
1865 		stv0367_writereg(state, R367CAB_EQU_CRL_LD_SEN, 0x85);
1866 		stv0367_writereg(state, R367CAB_EQU_CRL_LIMITER, 0x40);
1867 		stv0367_writereg(state, R367CAB_EQU_PNT_GAIN, 0xa7);
1868 		break;
1869 	case FE_CAB_MOD_QAM512:
1870 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1871 		break;
1872 	case FE_CAB_MOD_QAM1024:
1873 		stv0367_writereg(state, R367CAB_IQDEM_ADJ_AGC_REF, 0x00);
1874 		break;
1875 	default:
1876 		break;
1877 	}
1878 
1879 	return QAMSize;
1880 }
1881 
1882 static u32 stv0367cab_set_derot_freq(struct stv0367_state *state,
1883 					u32 adc_hz, s32 derot_hz)
1884 {
1885 	u32 sampled_if = 0;
1886 	u32 adc_khz;
1887 
1888 	adc_khz = adc_hz / 1000;
1889 
1890 	dprintk("%s: adc_hz=%d derot_hz=%d\n", __func__, adc_hz, derot_hz);
1891 
1892 	if (adc_khz != 0) {
1893 		if (derot_hz < 1000000)
1894 			derot_hz = adc_hz / 4; /* ZIF operation */
1895 		if (derot_hz > adc_hz)
1896 			derot_hz = derot_hz - adc_hz;
1897 		sampled_if = (u32)derot_hz / 1000;
1898 		sampled_if *= 32768;
1899 		sampled_if /= adc_khz;
1900 		sampled_if *= 256;
1901 	}
1902 
1903 	if (sampled_if > 8388607)
1904 		sampled_if = 8388607;
1905 
1906 	dprintk("%s: sampled_if=0x%x\n", __func__, sampled_if);
1907 
1908 	stv0367_writereg(state, R367CAB_MIX_NCO_LL, sampled_if);
1909 	stv0367_writereg(state, R367CAB_MIX_NCO_HL, (sampled_if >> 8));
1910 	stv0367_writebits(state, F367CAB_MIX_NCO_INC_HH, (sampled_if >> 16));
1911 
1912 	return derot_hz;
1913 }
1914 
1915 static u32 stv0367cab_get_derot_freq(struct stv0367_state *state, u32 adc_hz)
1916 {
1917 	u32 sampled_if;
1918 
1919 	sampled_if = stv0367_readbits(state, F367CAB_MIX_NCO_INC_LL) +
1920 			(stv0367_readbits(state, F367CAB_MIX_NCO_INC_HL) << 8) +
1921 			(stv0367_readbits(state, F367CAB_MIX_NCO_INC_HH) << 16);
1922 
1923 	sampled_if /= 256;
1924 	sampled_if *= (adc_hz / 1000);
1925 	sampled_if += 1;
1926 	sampled_if /= 32768;
1927 
1928 	return sampled_if;
1929 }
1930 
1931 static u32 stv0367cab_set_srate(struct stv0367_state *state, u32 adc_hz,
1932 			u32 mclk_hz, u32 SymbolRate,
1933 			enum stv0367cab_mod QAMSize)
1934 {
1935 	u32 QamSizeCorr = 0;
1936 	u32 u32_tmp = 0, u32_tmp1 = 0;
1937 	u32 adp_khz;
1938 
1939 	dprintk("%s:\n", __func__);
1940 
1941 	/* Set Correction factor of SRC gain */
1942 	switch (QAMSize) {
1943 	case FE_CAB_MOD_QAM4:
1944 		QamSizeCorr = 1110;
1945 		break;
1946 	case FE_CAB_MOD_QAM16:
1947 		QamSizeCorr = 1032;
1948 		break;
1949 	case FE_CAB_MOD_QAM32:
1950 		QamSizeCorr =  954;
1951 		break;
1952 	case FE_CAB_MOD_QAM64:
1953 		QamSizeCorr =  983;
1954 		break;
1955 	case FE_CAB_MOD_QAM128:
1956 		QamSizeCorr =  957;
1957 		break;
1958 	case FE_CAB_MOD_QAM256:
1959 		QamSizeCorr =  948;
1960 		break;
1961 	case FE_CAB_MOD_QAM512:
1962 		QamSizeCorr =    0;
1963 		break;
1964 	case FE_CAB_MOD_QAM1024:
1965 		QamSizeCorr =  944;
1966 		break;
1967 	default:
1968 		break;
1969 	}
1970 
1971 	/* Transfer ratio calculation */
1972 	if (adc_hz != 0) {
1973 		u32_tmp = 256 * SymbolRate;
1974 		u32_tmp = u32_tmp / adc_hz;
1975 	}
1976 	stv0367_writereg(state, R367CAB_EQU_CRL_TFR, (u8)u32_tmp);
1977 
1978 	/* Symbol rate and SRC gain calculation */
1979 	adp_khz = (mclk_hz >> 1) / 1000;/* TRL works at half the system clock */
1980 	if (adp_khz != 0) {
1981 		u32_tmp = SymbolRate;
1982 		u32_tmp1 = SymbolRate;
1983 
1984 		if (u32_tmp < 2097152) { /* 2097152 = 2^21 */
1985 			/* Symbol rate calculation */
1986 			u32_tmp *= 2048; /* 2048 = 2^11 */
1987 			u32_tmp = u32_tmp / adp_khz;
1988 			u32_tmp = u32_tmp * 16384; /* 16384 = 2^14 */
1989 			u32_tmp /= 125 ; /* 125 = 1000/2^3 */
1990 			u32_tmp = u32_tmp * 8; /* 8 = 2^3 */
1991 
1992 			/* SRC Gain Calculation */
1993 			u32_tmp1 *= 2048; /* *2*2^10 */
1994 			u32_tmp1 /= 439; /* *2/878 */
1995 			u32_tmp1 *= 256; /* *2^8 */
1996 			u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz) */
1997 			u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
1998 			u32_tmp1 = u32_tmp1 / 10000000;
1999 
2000 		} else if (u32_tmp < 4194304) { /* 4194304 = 2**22 */
2001 			/* Symbol rate calculation */
2002 			u32_tmp *= 1024 ; /* 1024 = 2**10 */
2003 			u32_tmp = u32_tmp / adp_khz;
2004 			u32_tmp = u32_tmp * 16384; /* 16384 = 2**14 */
2005 			u32_tmp /= 125 ; /* 125 = 1000/2**3 */
2006 			u32_tmp = u32_tmp * 16; /* 16 = 2**4 */
2007 
2008 			/* SRC Gain Calculation */
2009 			u32_tmp1 *= 1024; /* *2*2^9 */
2010 			u32_tmp1 /= 439; /* *2/878 */
2011 			u32_tmp1 *= 256; /* *2^8 */
2012 			u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz)*/
2013 			u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2014 			u32_tmp1 = u32_tmp1 / 5000000;
2015 		} else if (u32_tmp < 8388607) { /* 8388607 = 2**23 */
2016 			/* Symbol rate calculation */
2017 			u32_tmp *= 512 ; /* 512 = 2**9 */
2018 			u32_tmp = u32_tmp / adp_khz;
2019 			u32_tmp = u32_tmp * 16384; /* 16384 = 2**14 */
2020 			u32_tmp /= 125 ; /* 125 = 1000/2**3 */
2021 			u32_tmp = u32_tmp * 32; /* 32 = 2**5 */
2022 
2023 			/* SRC Gain Calculation */
2024 			u32_tmp1 *= 512; /* *2*2^8 */
2025 			u32_tmp1 /= 439; /* *2/878 */
2026 			u32_tmp1 *= 256; /* *2^8 */
2027 			u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz) */
2028 			u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2029 			u32_tmp1 = u32_tmp1 / 2500000;
2030 		} else {
2031 			/* Symbol rate calculation */
2032 			u32_tmp *= 256 ; /* 256 = 2**8 */
2033 			u32_tmp = u32_tmp / adp_khz;
2034 			u32_tmp = u32_tmp * 16384; /* 16384 = 2**13 */
2035 			u32_tmp /= 125 ; /* 125 = 1000/2**3 */
2036 			u32_tmp = u32_tmp * 64; /* 64 = 2**6 */
2037 
2038 			/* SRC Gain Calculation */
2039 			u32_tmp1 *= 256; /* 2*2^7 */
2040 			u32_tmp1 /= 439; /* *2/878 */
2041 			u32_tmp1 *= 256; /* *2^8 */
2042 			u32_tmp1 = u32_tmp1 / adp_khz; /* /(AdpClk in kHz) */
2043 			u32_tmp1 *= QamSizeCorr * 9; /* *1000*corr factor */
2044 			u32_tmp1 = u32_tmp1 / 1250000;
2045 		}
2046 	}
2047 #if 0
2048 	/* Filters' coefficients are calculated and written
2049 	into registers only if the filters are enabled */
2050 	if (stv0367_readbits(state, F367CAB_ADJ_EN)) {
2051 		stv0367cab_SetIirAdjacentcoefficient(state, mclk_hz,
2052 								SymbolRate);
2053 		/* AllPass filter must be enabled
2054 		when the adjacents filter is used */
2055 		stv0367_writebits(state, F367CAB_ALLPASSFILT_EN, 1);
2056 		stv0367cab_SetAllPasscoefficient(state, mclk_hz, SymbolRate);
2057 	} else
2058 		/* AllPass filter must be disabled
2059 		when the adjacents filter is not used */
2060 #endif
2061 	stv0367_writebits(state, F367CAB_ALLPASSFILT_EN, 0);
2062 
2063 	stv0367_writereg(state, R367CAB_SRC_NCO_LL, u32_tmp);
2064 	stv0367_writereg(state, R367CAB_SRC_NCO_LH, (u32_tmp >> 8));
2065 	stv0367_writereg(state, R367CAB_SRC_NCO_HL, (u32_tmp >> 16));
2066 	stv0367_writereg(state, R367CAB_SRC_NCO_HH, (u32_tmp >> 24));
2067 
2068 	stv0367_writereg(state, R367CAB_IQDEM_GAIN_SRC_L, u32_tmp1 & 0x00ff);
2069 	stv0367_writebits(state, F367CAB_GAIN_SRC_HI, (u32_tmp1 >> 8) & 0x00ff);
2070 
2071 	return SymbolRate ;
2072 }
2073 
2074 static u32 stv0367cab_GetSymbolRate(struct stv0367_state *state, u32 mclk_hz)
2075 {
2076 	u32 regsym;
2077 	u32 adp_khz;
2078 
2079 	regsym = stv0367_readreg(state, R367CAB_SRC_NCO_LL) +
2080 		(stv0367_readreg(state, R367CAB_SRC_NCO_LH) << 8) +
2081 		(stv0367_readreg(state, R367CAB_SRC_NCO_HL) << 16) +
2082 		(stv0367_readreg(state, R367CAB_SRC_NCO_HH) << 24);
2083 
2084 	adp_khz = (mclk_hz >> 1) / 1000;/* TRL works at half the system clock */
2085 
2086 	if (regsym < 134217728) {		/* 134217728L = 2**27*/
2087 		regsym = regsym * 32;		/* 32 = 2**5 */
2088 		regsym = regsym / 32768;	/* 32768L = 2**15 */
2089 		regsym = adp_khz * regsym;	/* AdpClk in kHz */
2090 		regsym = regsym / 128;		/* 128 = 2**7 */
2091 		regsym *= 125 ;			/* 125 = 1000/2**3 */
2092 		regsym /= 2048 ;		/* 2048 = 2**11	*/
2093 	} else if (regsym < 268435456) {	/* 268435456L = 2**28 */
2094 		regsym = regsym * 16;		/* 16 = 2**4 */
2095 		regsym = regsym / 32768;	/* 32768L = 2**15 */
2096 		regsym = adp_khz * regsym;	/* AdpClk in kHz */
2097 		regsym = regsym / 128;		/* 128 = 2**7 */
2098 		regsym *= 125 ;			/* 125 = 1000/2**3*/
2099 		regsym /= 1024 ;		/* 256 = 2**10*/
2100 	} else if (regsym < 536870912) {	/* 536870912L = 2**29*/
2101 		regsym = regsym * 8;		/* 8 = 2**3 */
2102 		regsym = regsym / 32768;	/* 32768L = 2**15 */
2103 		regsym = adp_khz * regsym;	/* AdpClk in kHz */
2104 		regsym = regsym / 128;		/* 128 = 2**7 */
2105 		regsym *= 125 ;			/* 125 = 1000/2**3 */
2106 		regsym /= 512 ;			/* 128 = 2**9 */
2107 	} else {
2108 		regsym = regsym * 4;		/* 4 = 2**2 */
2109 		regsym = regsym / 32768;	/* 32768L = 2**15 */
2110 		regsym = adp_khz * regsym;	/* AdpClk in kHz */
2111 		regsym = regsym / 128;		/* 128 = 2**7 */
2112 		regsym *= 125 ;			/* 125 = 1000/2**3 */
2113 		regsym /= 256 ;			/* 64 = 2**8 */
2114 	}
2115 
2116 	return regsym;
2117 }
2118 
2119 static u32 stv0367cab_fsm_status(struct stv0367_state *state)
2120 {
2121 	return stv0367_readbits(state, F367CAB_FSM_STATUS);
2122 }
2123 
2124 static u32 stv0367cab_qamfec_lock(struct stv0367_state *state)
2125 {
2126 	return stv0367_readbits(state,
2127 		(state->cab_state->qamfec_status_reg ?
2128 		 state->cab_state->qamfec_status_reg :
2129 		 F367CAB_QAMFEC_LOCK));
2130 }
2131 
2132 static
2133 enum stv0367_cab_signal_type stv0367cab_fsm_signaltype(u32 qam_fsm_status)
2134 {
2135 	enum stv0367_cab_signal_type signaltype = FE_CAB_NOAGC;
2136 
2137 	switch (qam_fsm_status) {
2138 	case 1:
2139 		signaltype = FE_CAB_NOAGC;
2140 		break;
2141 	case 2:
2142 		signaltype = FE_CAB_NOTIMING;
2143 		break;
2144 	case 3:
2145 		signaltype = FE_CAB_TIMINGOK;
2146 		break;
2147 	case 4:
2148 		signaltype = FE_CAB_NOCARRIER;
2149 		break;
2150 	case 5:
2151 		signaltype = FE_CAB_CARRIEROK;
2152 		break;
2153 	case 7:
2154 		signaltype = FE_CAB_NOBLIND;
2155 		break;
2156 	case 8:
2157 		signaltype = FE_CAB_BLINDOK;
2158 		break;
2159 	case 10:
2160 		signaltype = FE_CAB_NODEMOD;
2161 		break;
2162 	case 11:
2163 		signaltype = FE_CAB_DEMODOK;
2164 		break;
2165 	case 12:
2166 		signaltype = FE_CAB_DEMODOK;
2167 		break;
2168 	case 13:
2169 		signaltype = FE_CAB_NODEMOD;
2170 		break;
2171 	case 14:
2172 		signaltype = FE_CAB_NOBLIND;
2173 		break;
2174 	case 15:
2175 		signaltype = FE_CAB_NOSIGNAL;
2176 		break;
2177 	default:
2178 		break;
2179 	}
2180 
2181 	return signaltype;
2182 }
2183 
2184 static int stv0367cab_read_status(struct dvb_frontend *fe,
2185 				  enum fe_status *status)
2186 {
2187 	struct stv0367_state *state = fe->demodulator_priv;
2188 
2189 	dprintk("%s:\n", __func__);
2190 
2191 	*status = 0;
2192 
2193 	/* update cab_state->state from QAM_FSM_STATUS */
2194 	state->cab_state->state = stv0367cab_fsm_signaltype(
2195 		stv0367cab_fsm_status(state));
2196 
2197 	if (stv0367cab_qamfec_lock(state)) {
2198 		*status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI
2199 			  | FE_HAS_SYNC | FE_HAS_LOCK;
2200 		dprintk("%s: stv0367 has locked\n", __func__);
2201 	} else {
2202 		if (state->cab_state->state > FE_CAB_NOSIGNAL)
2203 			*status |= FE_HAS_SIGNAL;
2204 
2205 		if (state->cab_state->state > FE_CAB_NOCARRIER)
2206 			*status |= FE_HAS_CARRIER;
2207 
2208 		if (state->cab_state->state >= FE_CAB_DEMODOK)
2209 			*status |= FE_HAS_VITERBI;
2210 
2211 		if (state->cab_state->state >= FE_CAB_DATAOK)
2212 			*status |= FE_HAS_SYNC;
2213 	}
2214 
2215 	return 0;
2216 }
2217 
2218 static int stv0367cab_standby(struct dvb_frontend *fe, u8 standby_on)
2219 {
2220 	struct stv0367_state *state = fe->demodulator_priv;
2221 
2222 	dprintk("%s:\n", __func__);
2223 
2224 	if (standby_on) {
2225 		stv0367_writebits(state, F367CAB_BYPASS_PLLXN, 0x03);
2226 		stv0367_writebits(state, F367CAB_STDBY_PLLXN, 0x01);
2227 		stv0367_writebits(state, F367CAB_STDBY, 1);
2228 		stv0367_writebits(state, F367CAB_STDBY_CORE, 1);
2229 		stv0367_writebits(state, F367CAB_EN_BUFFER_I, 0);
2230 		stv0367_writebits(state, F367CAB_EN_BUFFER_Q, 0);
2231 		stv0367_writebits(state, F367CAB_POFFQ, 1);
2232 		stv0367_writebits(state, F367CAB_POFFI, 1);
2233 	} else {
2234 		stv0367_writebits(state, F367CAB_STDBY_PLLXN, 0x00);
2235 		stv0367_writebits(state, F367CAB_BYPASS_PLLXN, 0x00);
2236 		stv0367_writebits(state, F367CAB_STDBY, 0);
2237 		stv0367_writebits(state, F367CAB_STDBY_CORE, 0);
2238 		stv0367_writebits(state, F367CAB_EN_BUFFER_I, 1);
2239 		stv0367_writebits(state, F367CAB_EN_BUFFER_Q, 1);
2240 		stv0367_writebits(state, F367CAB_POFFQ, 0);
2241 		stv0367_writebits(state, F367CAB_POFFI, 0);
2242 	}
2243 
2244 	return 0;
2245 }
2246 
2247 static int stv0367cab_sleep(struct dvb_frontend *fe)
2248 {
2249 	return stv0367cab_standby(fe, 1);
2250 }
2251 
2252 static int stv0367cab_init(struct dvb_frontend *fe)
2253 {
2254 	struct stv0367_state *state = fe->demodulator_priv;
2255 	struct stv0367cab_state *cab_state = state->cab_state;
2256 
2257 	dprintk("%s:\n", __func__);
2258 
2259 	stv0367_write_table(state,
2260 		stv0367_deftabs[state->deftabs][STV0367_TAB_CAB]);
2261 
2262 	switch (state->config->ts_mode) {
2263 	case STV0367_DVBCI_CLOCK:
2264 		dprintk("Setting TSMode = STV0367_DVBCI_CLOCK\n");
2265 		stv0367_writebits(state, F367CAB_OUTFORMAT, 0x03);
2266 		break;
2267 	case STV0367_SERIAL_PUNCT_CLOCK:
2268 	case STV0367_SERIAL_CONT_CLOCK:
2269 		stv0367_writebits(state, F367CAB_OUTFORMAT, 0x01);
2270 		break;
2271 	case STV0367_PARALLEL_PUNCT_CLOCK:
2272 	case STV0367_OUTPUTMODE_DEFAULT:
2273 		stv0367_writebits(state, F367CAB_OUTFORMAT, 0x00);
2274 		break;
2275 	}
2276 
2277 	switch (state->config->clk_pol) {
2278 	case STV0367_RISINGEDGE_CLOCK:
2279 		stv0367_writebits(state, F367CAB_CLK_POLARITY, 0x00);
2280 		break;
2281 	case STV0367_FALLINGEDGE_CLOCK:
2282 	case STV0367_CLOCKPOLARITY_DEFAULT:
2283 		stv0367_writebits(state, F367CAB_CLK_POLARITY, 0x01);
2284 		break;
2285 	}
2286 
2287 	stv0367_writebits(state, F367CAB_SYNC_STRIP, 0x00);
2288 
2289 	stv0367_writebits(state, F367CAB_CT_NBST, 0x01);
2290 
2291 	stv0367_writebits(state, F367CAB_TS_SWAP, 0x01);
2292 
2293 	stv0367_writebits(state, F367CAB_FIFO_BYPASS, 0x00);
2294 
2295 	stv0367_writereg(state, R367CAB_ANACTRL, 0x00);/*PLL enabled and used */
2296 
2297 	cab_state->mclk = stv0367cab_get_mclk(fe, state->config->xtal);
2298 	cab_state->adc_clk = stv0367cab_get_adc_freq(fe, state->config->xtal);
2299 
2300 	return 0;
2301 }
2302 static
2303 enum stv0367_cab_signal_type stv0367cab_algo(struct stv0367_state *state,
2304 					     struct dtv_frontend_properties *p)
2305 {
2306 	struct stv0367cab_state *cab_state = state->cab_state;
2307 	enum stv0367_cab_signal_type signalType = FE_CAB_NOAGC;
2308 	u32	QAMFEC_Lock, QAM_Lock, u32_tmp, ifkhz,
2309 		LockTime, TRLTimeOut, AGCTimeOut, CRLSymbols,
2310 		CRLTimeOut, EQLTimeOut, DemodTimeOut, FECTimeOut;
2311 	u8	TrackAGCAccum;
2312 	s32	tmp;
2313 
2314 	dprintk("%s:\n", __func__);
2315 
2316 	stv0367_get_if_khz(state, &ifkhz);
2317 
2318 	/* Timeouts calculation */
2319 	/* A max lock time of 25 ms is allowed for delayed AGC */
2320 	AGCTimeOut = 25;
2321 	/* 100000 symbols needed by the TRL as a maximum value */
2322 	TRLTimeOut = 100000000 / p->symbol_rate;
2323 	/* CRLSymbols is the needed number of symbols to achieve a lock
2324 	   within [-4%, +4%] of the symbol rate.
2325 	   CRL timeout is calculated
2326 	   for a lock within [-search_range, +search_range].
2327 	   EQL timeout can be changed depending on
2328 	   the micro-reflections we want to handle.
2329 	   A characterization must be performed
2330 	   with these echoes to get new timeout values.
2331 	*/
2332 	switch (p->modulation) {
2333 	case QAM_16:
2334 		CRLSymbols = 150000;
2335 		EQLTimeOut = 100;
2336 		break;
2337 	case QAM_32:
2338 		CRLSymbols = 250000;
2339 		EQLTimeOut = 100;
2340 		break;
2341 	case QAM_64:
2342 		CRLSymbols = 200000;
2343 		EQLTimeOut = 100;
2344 		break;
2345 	case QAM_128:
2346 		CRLSymbols = 250000;
2347 		EQLTimeOut = 100;
2348 		break;
2349 	case QAM_256:
2350 		CRLSymbols = 250000;
2351 		EQLTimeOut = 100;
2352 		break;
2353 	default:
2354 		CRLSymbols = 200000;
2355 		EQLTimeOut = 100;
2356 		break;
2357 	}
2358 #if 0
2359 	if (pIntParams->search_range < 0) {
2360 		CRLTimeOut = (25 * CRLSymbols *
2361 				(-pIntParams->search_range / 1000)) /
2362 					(pIntParams->symbol_rate / 1000);
2363 	} else
2364 #endif
2365 	CRLTimeOut = (25 * CRLSymbols * (cab_state->search_range / 1000)) /
2366 					(p->symbol_rate / 1000);
2367 
2368 	CRLTimeOut = (1000 * CRLTimeOut) / p->symbol_rate;
2369 	/* Timeouts below 50ms are coerced */
2370 	if (CRLTimeOut < 50)
2371 		CRLTimeOut = 50;
2372 	/* A maximum of 100 TS packets is needed to get FEC lock even in case
2373 	the spectrum inversion needs to be changed.
2374 	   This is equal to 20 ms in case of the lowest symbol rate of 0.87Msps
2375 	*/
2376 	FECTimeOut = 20;
2377 	DemodTimeOut = AGCTimeOut + TRLTimeOut + CRLTimeOut + EQLTimeOut;
2378 
2379 	dprintk("%s: DemodTimeOut=%d\n", __func__, DemodTimeOut);
2380 
2381 	/* Reset the TRL to ensure nothing starts until the
2382 	   AGC is stable which ensures a better lock time
2383 	*/
2384 	stv0367_writereg(state, R367CAB_CTRL_1, 0x04);
2385 	/* Set AGC accumulation time to minimum and lock threshold to maximum
2386 	in order to speed up the AGC lock */
2387 	TrackAGCAccum = stv0367_readbits(state, F367CAB_AGC_ACCUMRSTSEL);
2388 	stv0367_writebits(state, F367CAB_AGC_ACCUMRSTSEL, 0x0);
2389 	/* Modulus Mapper is disabled */
2390 	stv0367_writebits(state, F367CAB_MODULUSMAP_EN, 0);
2391 	/* Disable the sweep function */
2392 	stv0367_writebits(state, F367CAB_SWEEP_EN, 0);
2393 	/* The sweep function is never used, Sweep rate must be set to 0 */
2394 	/* Set the derotator frequency in Hz */
2395 	stv0367cab_set_derot_freq(state, cab_state->adc_clk,
2396 		(1000 * (s32)ifkhz + cab_state->derot_offset));
2397 	/* Disable the Allpass Filter when the symbol rate is out of range */
2398 	if ((p->symbol_rate > 10800000) | (p->symbol_rate < 1800000)) {
2399 		stv0367_writebits(state, F367CAB_ADJ_EN, 0);
2400 		stv0367_writebits(state, F367CAB_ALLPASSFILT_EN, 0);
2401 	}
2402 #if 0
2403 	/* Check if the tuner is locked */
2404 	tuner_lock = stv0367cab_tuner_get_status(fe);
2405 	if (tuner_lock == 0)
2406 		return FE_367CAB_NOTUNER;
2407 #endif
2408 	/* Release the TRL to start demodulator acquisition */
2409 	/* Wait for QAM lock */
2410 	LockTime = 0;
2411 	stv0367_writereg(state, R367CAB_CTRL_1, 0x00);
2412 	do {
2413 		QAM_Lock = stv0367cab_fsm_status(state);
2414 		if ((LockTime >= (DemodTimeOut - EQLTimeOut)) &&
2415 							(QAM_Lock == 0x04))
2416 			/*
2417 			 * We don't wait longer, the frequency/phase offset
2418 			 * must be too big
2419 			 */
2420 			LockTime = DemodTimeOut;
2421 		else if ((LockTime >= (AGCTimeOut + TRLTimeOut)) &&
2422 							(QAM_Lock == 0x02))
2423 			/*
2424 			 * We don't wait longer, either there is no signal or
2425 			 * it is not the right symbol rate or it is an analog
2426 			 * carrier
2427 			 */
2428 		{
2429 			LockTime = DemodTimeOut;
2430 			u32_tmp = stv0367_readbits(state,
2431 						F367CAB_AGC_PWR_WORD_LO) +
2432 					(stv0367_readbits(state,
2433 						F367CAB_AGC_PWR_WORD_ME) << 8) +
2434 					(stv0367_readbits(state,
2435 						F367CAB_AGC_PWR_WORD_HI) << 16);
2436 			if (u32_tmp >= 131072)
2437 				u32_tmp = 262144 - u32_tmp;
2438 			u32_tmp = u32_tmp / (1 << (11 - stv0367_readbits(state,
2439 							F367CAB_AGC_IF_BWSEL)));
2440 
2441 			if (u32_tmp < stv0367_readbits(state,
2442 						F367CAB_AGC_PWRREF_LO) +
2443 					256 * stv0367_readbits(state,
2444 						F367CAB_AGC_PWRREF_HI) - 10)
2445 				QAM_Lock = 0x0f;
2446 		} else {
2447 			usleep_range(10000, 20000);
2448 			LockTime += 10;
2449 		}
2450 		dprintk("QAM_Lock=0x%x LockTime=%d\n", QAM_Lock, LockTime);
2451 		tmp = stv0367_readreg(state, R367CAB_IT_STATUS1);
2452 
2453 		dprintk("R367CAB_IT_STATUS1=0x%x\n", tmp);
2454 
2455 	} while (((QAM_Lock != 0x0c) && (QAM_Lock != 0x0b)) &&
2456 						(LockTime < DemodTimeOut));
2457 
2458 	dprintk("QAM_Lock=0x%x\n", QAM_Lock);
2459 
2460 	tmp = stv0367_readreg(state, R367CAB_IT_STATUS1);
2461 	dprintk("R367CAB_IT_STATUS1=0x%x\n", tmp);
2462 	tmp = stv0367_readreg(state, R367CAB_IT_STATUS2);
2463 	dprintk("R367CAB_IT_STATUS2=0x%x\n", tmp);
2464 
2465 	tmp  = stv0367cab_get_derot_freq(state, cab_state->adc_clk);
2466 	dprintk("stv0367cab_get_derot_freq=0x%x\n", tmp);
2467 
2468 	if ((QAM_Lock == 0x0c) || (QAM_Lock == 0x0b)) {
2469 		/* Wait for FEC lock */
2470 		LockTime = 0;
2471 		do {
2472 			usleep_range(5000, 7000);
2473 			LockTime += 5;
2474 			QAMFEC_Lock = stv0367cab_qamfec_lock(state);
2475 		} while (!QAMFEC_Lock && (LockTime < FECTimeOut));
2476 	} else
2477 		QAMFEC_Lock = 0;
2478 
2479 	if (QAMFEC_Lock) {
2480 		signalType = FE_CAB_DATAOK;
2481 		cab_state->spect_inv = stv0367_readbits(state,
2482 							F367CAB_QUAD_INV);
2483 #if 0
2484 /* not clear for me */
2485 		if (ifkhz != 0) {
2486 			if (ifkhz > cab_state->adc_clk / 1000) {
2487 				cab_state->freq_khz =
2488 					FE_Cab_TunerGetFrequency(pIntParams->hTuner)
2489 				- stv0367cab_get_derot_freq(state, cab_state->adc_clk)
2490 				- cab_state->adc_clk / 1000 + ifkhz;
2491 			} else {
2492 				cab_state->freq_khz =
2493 						FE_Cab_TunerGetFrequency(pIntParams->hTuner)
2494 						- stv0367cab_get_derot_freq(state, cab_state->adc_clk)
2495 						+ ifkhz;
2496 			}
2497 		} else {
2498 			cab_state->freq_khz =
2499 				FE_Cab_TunerGetFrequency(pIntParams->hTuner) +
2500 				stv0367cab_get_derot_freq(state,
2501 							cab_state->adc_clk) -
2502 				cab_state->adc_clk / 4000;
2503 		}
2504 #endif
2505 		cab_state->symbol_rate = stv0367cab_GetSymbolRate(state,
2506 							cab_state->mclk);
2507 		cab_state->locked = 1;
2508 
2509 		/* stv0367_setbits(state, F367CAB_AGC_ACCUMRSTSEL,7);*/
2510 	} else
2511 		signalType = stv0367cab_fsm_signaltype(QAM_Lock);
2512 
2513 	/* Set the AGC control values to tracking values */
2514 	stv0367_writebits(state, F367CAB_AGC_ACCUMRSTSEL, TrackAGCAccum);
2515 	return signalType;
2516 }
2517 
2518 static int stv0367cab_set_frontend(struct dvb_frontend *fe)
2519 {
2520 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
2521 	struct stv0367_state *state = fe->demodulator_priv;
2522 	struct stv0367cab_state *cab_state = state->cab_state;
2523 	enum stv0367cab_mod QAMSize = 0;
2524 
2525 	dprintk("%s: freq = %d, srate = %d\n", __func__,
2526 					p->frequency, p->symbol_rate);
2527 
2528 	cab_state->derot_offset = 0;
2529 
2530 	switch (p->modulation) {
2531 	case QAM_16:
2532 		QAMSize = FE_CAB_MOD_QAM16;
2533 		break;
2534 	case QAM_32:
2535 		QAMSize = FE_CAB_MOD_QAM32;
2536 		break;
2537 	case QAM_64:
2538 		QAMSize = FE_CAB_MOD_QAM64;
2539 		break;
2540 	case QAM_128:
2541 		QAMSize = FE_CAB_MOD_QAM128;
2542 		break;
2543 	case QAM_256:
2544 		QAMSize = FE_CAB_MOD_QAM256;
2545 		break;
2546 	default:
2547 		break;
2548 	}
2549 
2550 	if (state->reinit_on_setfrontend)
2551 		stv0367cab_init(fe);
2552 
2553 	/* Tuner Frequency Setting */
2554 	if (fe->ops.tuner_ops.set_params) {
2555 		if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
2556 			fe->ops.i2c_gate_ctrl(fe, 1);
2557 		fe->ops.tuner_ops.set_params(fe);
2558 		if (state->use_i2c_gatectrl && fe->ops.i2c_gate_ctrl)
2559 			fe->ops.i2c_gate_ctrl(fe, 0);
2560 	}
2561 
2562 	stv0367cab_SetQamSize(
2563 			state,
2564 			p->symbol_rate,
2565 			QAMSize);
2566 
2567 	stv0367cab_set_srate(state,
2568 			cab_state->adc_clk,
2569 			cab_state->mclk,
2570 			p->symbol_rate,
2571 			QAMSize);
2572 	/* Search algorithm launch, [-1.1*RangeOffset, +1.1*RangeOffset] scan */
2573 	cab_state->state = stv0367cab_algo(state, p);
2574 	return 0;
2575 }
2576 
2577 static int stv0367cab_get_frontend(struct dvb_frontend *fe,
2578 				   struct dtv_frontend_properties *p)
2579 {
2580 	struct stv0367_state *state = fe->demodulator_priv;
2581 	struct stv0367cab_state *cab_state = state->cab_state;
2582 	u32 ifkhz = 0;
2583 
2584 	enum stv0367cab_mod QAMSize;
2585 
2586 	dprintk("%s:\n", __func__);
2587 
2588 	stv0367_get_if_khz(state, &ifkhz);
2589 	p->symbol_rate = stv0367cab_GetSymbolRate(state, cab_state->mclk);
2590 
2591 	QAMSize = stv0367_readbits(state, F367CAB_QAM_MODE);
2592 	switch (QAMSize) {
2593 	case FE_CAB_MOD_QAM16:
2594 		p->modulation = QAM_16;
2595 		break;
2596 	case FE_CAB_MOD_QAM32:
2597 		p->modulation = QAM_32;
2598 		break;
2599 	case FE_CAB_MOD_QAM64:
2600 		p->modulation = QAM_64;
2601 		break;
2602 	case FE_CAB_MOD_QAM128:
2603 		p->modulation = QAM_128;
2604 		break;
2605 	case FE_CAB_MOD_QAM256:
2606 		p->modulation = QAM_256;
2607 		break;
2608 	default:
2609 		break;
2610 	}
2611 
2612 	p->frequency = stv0367_get_tuner_freq(fe);
2613 
2614 	dprintk("%s: tuner frequency = %d\n", __func__, p->frequency);
2615 
2616 	if (ifkhz == 0) {
2617 		p->frequency +=
2618 			(stv0367cab_get_derot_freq(state, cab_state->adc_clk) -
2619 			cab_state->adc_clk / 4000);
2620 		return 0;
2621 	}
2622 
2623 	if (ifkhz > cab_state->adc_clk / 1000)
2624 		p->frequency += (ifkhz
2625 			- stv0367cab_get_derot_freq(state, cab_state->adc_clk)
2626 			- cab_state->adc_clk / 1000);
2627 	else
2628 		p->frequency += (ifkhz
2629 			- stv0367cab_get_derot_freq(state, cab_state->adc_clk));
2630 
2631 	return 0;
2632 }
2633 
2634 #if 0
2635 void stv0367cab_GetErrorCount(state, enum stv0367cab_mod QAMSize,
2636 			u32 symbol_rate, FE_367qam_Monitor *Monitor_results)
2637 {
2638 	stv0367cab_OptimiseNByteAndGetBER(state, QAMSize, symbol_rate, Monitor_results);
2639 	stv0367cab_GetPacketsCount(state, Monitor_results);
2640 
2641 	return;
2642 }
2643 
2644 static int stv0367cab_read_ber(struct dvb_frontend *fe, u32 *ber)
2645 {
2646 	struct stv0367_state *state = fe->demodulator_priv;
2647 
2648 	return 0;
2649 }
2650 #endif
2651 static s32 stv0367cab_get_rf_lvl(struct stv0367_state *state)
2652 {
2653 	s32 rfLevel = 0;
2654 	s32 RfAgcPwm = 0, IfAgcPwm = 0;
2655 	u8 i;
2656 
2657 	stv0367_writebits(state, F367CAB_STDBY_ADCGP, 0x0);
2658 
2659 	RfAgcPwm =
2660 		(stv0367_readbits(state, F367CAB_RF_AGC1_LEVEL_LO) & 0x03) +
2661 		(stv0367_readbits(state, F367CAB_RF_AGC1_LEVEL_HI) << 2);
2662 	RfAgcPwm = 100 * RfAgcPwm / 1023;
2663 
2664 	IfAgcPwm =
2665 		stv0367_readbits(state, F367CAB_AGC_IF_PWMCMD_LO) +
2666 		(stv0367_readbits(state, F367CAB_AGC_IF_PWMCMD_HI) << 8);
2667 	if (IfAgcPwm >= 2048)
2668 		IfAgcPwm -= 2048;
2669 	else
2670 		IfAgcPwm += 2048;
2671 
2672 	IfAgcPwm = 100 * IfAgcPwm / 4095;
2673 
2674 	/* For DTT75467 on NIM */
2675 	if (RfAgcPwm < 90  && IfAgcPwm < 28) {
2676 		for (i = 0; i < RF_LOOKUP_TABLE_SIZE; i++) {
2677 			if (RfAgcPwm <= stv0367cab_RF_LookUp1[0][i]) {
2678 				rfLevel = (-1) * stv0367cab_RF_LookUp1[1][i];
2679 				break;
2680 			}
2681 		}
2682 		if (i == RF_LOOKUP_TABLE_SIZE)
2683 			rfLevel = -56;
2684 	} else { /*if IF AGC>10*/
2685 		for (i = 0; i < RF_LOOKUP_TABLE2_SIZE; i++) {
2686 			if (IfAgcPwm <= stv0367cab_RF_LookUp2[0][i]) {
2687 				rfLevel = (-1) * stv0367cab_RF_LookUp2[1][i];
2688 				break;
2689 			}
2690 		}
2691 		if (i == RF_LOOKUP_TABLE2_SIZE)
2692 			rfLevel = -72;
2693 	}
2694 	return rfLevel;
2695 }
2696 
2697 static int stv0367cab_read_strength(struct dvb_frontend *fe, u16 *strength)
2698 {
2699 	struct stv0367_state *state = fe->demodulator_priv;
2700 
2701 	s32 signal =  stv0367cab_get_rf_lvl(state);
2702 
2703 	dprintk("%s: signal=%d dBm\n", __func__, signal);
2704 
2705 	if (signal <= -72)
2706 		*strength = 65535;
2707 	else
2708 		*strength = (22 + signal) * (-1311);
2709 
2710 	dprintk("%s: strength=%d\n", __func__, (*strength));
2711 
2712 	return 0;
2713 }
2714 
2715 static int stv0367cab_snr_power(struct dvb_frontend *fe)
2716 {
2717 	struct stv0367_state *state = fe->demodulator_priv;
2718 	enum stv0367cab_mod QAMSize;
2719 
2720 	QAMSize = stv0367_readbits(state, F367CAB_QAM_MODE);
2721 	switch (QAMSize) {
2722 	case FE_CAB_MOD_QAM4:
2723 		return 21904;
2724 	case FE_CAB_MOD_QAM16:
2725 		return 20480;
2726 	case FE_CAB_MOD_QAM32:
2727 		return 23040;
2728 	case FE_CAB_MOD_QAM64:
2729 		return 21504;
2730 	case FE_CAB_MOD_QAM128:
2731 		return 23616;
2732 	case FE_CAB_MOD_QAM256:
2733 		return 21760;
2734 	case FE_CAB_MOD_QAM1024:
2735 		return 21280;
2736 	default:
2737 		break;
2738 	}
2739 
2740 	return 1;
2741 }
2742 
2743 static int stv0367cab_snr_readreg(struct dvb_frontend *fe, int avgdiv)
2744 {
2745 	struct stv0367_state *state = fe->demodulator_priv;
2746 	u32 regval = 0;
2747 	int i;
2748 
2749 	for (i = 0; i < 10; i++) {
2750 		regval += (stv0367_readbits(state, F367CAB_SNR_LO)
2751 			+ 256 * stv0367_readbits(state, F367CAB_SNR_HI));
2752 	}
2753 
2754 	if (avgdiv)
2755 		regval /= 10;
2756 
2757 	return regval;
2758 }
2759 
2760 static int stv0367cab_read_snr(struct dvb_frontend *fe, u16 *snr)
2761 {
2762 	struct stv0367_state *state = fe->demodulator_priv;
2763 	u32 noisepercentage;
2764 	u32 regval = 0, temp = 0;
2765 	int power;
2766 
2767 	power = stv0367cab_snr_power(fe);
2768 	regval = stv0367cab_snr_readreg(fe, 1);
2769 
2770 	if (regval != 0) {
2771 		temp = power
2772 			* (1 << (3 + stv0367_readbits(state, F367CAB_SNR_PER)));
2773 		temp /= regval;
2774 	}
2775 
2776 	/* table values, not needed to calculate logarithms */
2777 	if (temp >= 5012)
2778 		noisepercentage = 100;
2779 	else if (temp >= 3981)
2780 		noisepercentage = 93;
2781 	else if (temp >= 3162)
2782 		noisepercentage = 86;
2783 	else if (temp >= 2512)
2784 		noisepercentage = 79;
2785 	else if (temp >= 1995)
2786 		noisepercentage = 72;
2787 	else if (temp >= 1585)
2788 		noisepercentage = 65;
2789 	else if (temp >= 1259)
2790 		noisepercentage = 58;
2791 	else if (temp >= 1000)
2792 		noisepercentage = 50;
2793 	else if (temp >= 794)
2794 		noisepercentage = 43;
2795 	else if (temp >= 501)
2796 		noisepercentage = 36;
2797 	else if (temp >= 316)
2798 		noisepercentage = 29;
2799 	else if (temp >= 200)
2800 		noisepercentage = 22;
2801 	else if (temp >= 158)
2802 		noisepercentage = 14;
2803 	else if (temp >= 126)
2804 		noisepercentage = 7;
2805 	else
2806 		noisepercentage = 0;
2807 
2808 	dprintk("%s: noisepercentage=%d\n", __func__, noisepercentage);
2809 
2810 	*snr = (noisepercentage * 65535) / 100;
2811 
2812 	return 0;
2813 }
2814 
2815 static int stv0367cab_read_ucblcks(struct dvb_frontend *fe, u32 *ucblocks)
2816 {
2817 	struct stv0367_state *state = fe->demodulator_priv;
2818 	int corrected, tscount;
2819 
2820 	*ucblocks = (stv0367_readreg(state, R367CAB_RS_COUNTER_5) << 8)
2821 			| stv0367_readreg(state, R367CAB_RS_COUNTER_4);
2822 	corrected = (stv0367_readreg(state, R367CAB_RS_COUNTER_3) << 8)
2823 			| stv0367_readreg(state, R367CAB_RS_COUNTER_2);
2824 	tscount = (stv0367_readreg(state, R367CAB_RS_COUNTER_2) << 8)
2825 			| stv0367_readreg(state, R367CAB_RS_COUNTER_1);
2826 
2827 	dprintk("%s: uncorrected blocks=%d corrected blocks=%d tscount=%d\n",
2828 				__func__, *ucblocks, corrected, tscount);
2829 
2830 	return 0;
2831 };
2832 
2833 static const struct dvb_frontend_ops stv0367cab_ops = {
2834 	.delsys = { SYS_DVBC_ANNEX_A },
2835 	.info = {
2836 		.name = "ST STV0367 DVB-C",
2837 		.frequency_min_hz =  47 * MHz,
2838 		.frequency_max_hz = 862 * MHz,
2839 		.frequency_stepsize_hz = 62500,
2840 		.symbol_rate_min = 870000,
2841 		.symbol_rate_max = 11700000,
2842 		.caps = 0x400 |/* FE_CAN_QAM_4 */
2843 			FE_CAN_QAM_16 | FE_CAN_QAM_32  |
2844 			FE_CAN_QAM_64 | FE_CAN_QAM_128 |
2845 			FE_CAN_QAM_256 | FE_CAN_FEC_AUTO
2846 	},
2847 	.release				= stv0367_release,
2848 	.init					= stv0367cab_init,
2849 	.sleep					= stv0367cab_sleep,
2850 	.i2c_gate_ctrl				= stv0367cab_gate_ctrl,
2851 	.set_frontend				= stv0367cab_set_frontend,
2852 	.get_frontend				= stv0367cab_get_frontend,
2853 	.read_status				= stv0367cab_read_status,
2854 /*	.read_ber				= stv0367cab_read_ber, */
2855 	.read_signal_strength			= stv0367cab_read_strength,
2856 	.read_snr				= stv0367cab_read_snr,
2857 	.read_ucblocks				= stv0367cab_read_ucblcks,
2858 	.get_tune_settings			= stv0367_get_tune_settings,
2859 };
2860 
2861 struct dvb_frontend *stv0367cab_attach(const struct stv0367_config *config,
2862 				   struct i2c_adapter *i2c)
2863 {
2864 	struct stv0367_state *state = NULL;
2865 	struct stv0367cab_state *cab_state = NULL;
2866 
2867 	/* allocate memory for the internal state */
2868 	state = kzalloc(sizeof(struct stv0367_state), GFP_KERNEL);
2869 	if (state == NULL)
2870 		goto error;
2871 	cab_state = kzalloc(sizeof(struct stv0367cab_state), GFP_KERNEL);
2872 	if (cab_state == NULL)
2873 		goto error;
2874 
2875 	/* setup the state */
2876 	state->i2c = i2c;
2877 	state->config = config;
2878 	cab_state->search_range = 280000;
2879 	cab_state->qamfec_status_reg = F367CAB_QAMFEC_LOCK;
2880 	state->cab_state = cab_state;
2881 	state->fe.ops = stv0367cab_ops;
2882 	state->fe.demodulator_priv = state;
2883 	state->chip_id = stv0367_readreg(state, 0xf000);
2884 
2885 	/* demod operation options */
2886 	state->use_i2c_gatectrl = 1;
2887 	state->deftabs = STV0367_DEFTAB_GENERIC;
2888 	state->reinit_on_setfrontend = 1;
2889 	state->auto_if_khz = 0;
2890 
2891 	dprintk("%s: chip_id = 0x%x\n", __func__, state->chip_id);
2892 
2893 	/* check if the demod is there */
2894 	if ((state->chip_id != 0x50) && (state->chip_id != 0x60))
2895 		goto error;
2896 
2897 	return &state->fe;
2898 
2899 error:
2900 	kfree(cab_state);
2901 	kfree(state);
2902 	return NULL;
2903 }
2904 EXPORT_SYMBOL_GPL(stv0367cab_attach);
2905 
2906 /*
2907  * Functions for operation on Digital Devices hardware
2908  */
2909 
2910 static void stv0367ddb_setup_ter(struct stv0367_state *state)
2911 {
2912 	stv0367_writereg(state, R367TER_DEBUG_LT4, 0x00);
2913 	stv0367_writereg(state, R367TER_DEBUG_LT5, 0x00);
2914 	stv0367_writereg(state, R367TER_DEBUG_LT6, 0x00); /* R367CAB_CTRL_1 */
2915 	stv0367_writereg(state, R367TER_DEBUG_LT7, 0x00); /* R367CAB_CTRL_2 */
2916 	stv0367_writereg(state, R367TER_DEBUG_LT8, 0x00);
2917 	stv0367_writereg(state, R367TER_DEBUG_LT9, 0x00);
2918 
2919 	/* Tuner Setup */
2920 	/* Buffer Q disabled, I Enabled, unsigned ADC */
2921 	stv0367_writereg(state, R367TER_ANADIGCTRL, 0x89);
2922 	stv0367_writereg(state, R367TER_DUAL_AD12, 0x04); /* ADCQ disabled */
2923 
2924 	/* Clock setup */
2925 	/* PLL bypassed and disabled */
2926 	stv0367_writereg(state, R367TER_ANACTRL, 0x0D);
2927 	stv0367_writereg(state, R367TER_TOPCTRL, 0x00); /* Set OFDM */
2928 
2929 	/* IC runs at 54 MHz with a 27 MHz crystal */
2930 	stv0367_pll_setup(state, STV0367_ICSPEED_53125, state->config->xtal);
2931 
2932 	msleep(50);
2933 	/* PLL enabled and used */
2934 	stv0367_writereg(state, R367TER_ANACTRL, 0x00);
2935 
2936 	state->activedemod = demod_ter;
2937 }
2938 
2939 static void stv0367ddb_setup_cab(struct stv0367_state *state)
2940 {
2941 	stv0367_writereg(state, R367TER_DEBUG_LT4, 0x00);
2942 	stv0367_writereg(state, R367TER_DEBUG_LT5, 0x01);
2943 	stv0367_writereg(state, R367TER_DEBUG_LT6, 0x06); /* R367CAB_CTRL_1 */
2944 	stv0367_writereg(state, R367TER_DEBUG_LT7, 0x03); /* R367CAB_CTRL_2 */
2945 	stv0367_writereg(state, R367TER_DEBUG_LT8, 0x00);
2946 	stv0367_writereg(state, R367TER_DEBUG_LT9, 0x00);
2947 
2948 	/* Tuner Setup */
2949 	/* Buffer Q disabled, I Enabled, signed ADC */
2950 	stv0367_writereg(state, R367TER_ANADIGCTRL, 0x8B);
2951 	/* ADCQ disabled */
2952 	stv0367_writereg(state, R367TER_DUAL_AD12, 0x04);
2953 
2954 	/* Clock setup */
2955 	/* PLL bypassed and disabled */
2956 	stv0367_writereg(state, R367TER_ANACTRL, 0x0D);
2957 	/* Set QAM */
2958 	stv0367_writereg(state, R367TER_TOPCTRL, 0x10);
2959 
2960 	/* IC runs at 58 MHz with a 27 MHz crystal */
2961 	stv0367_pll_setup(state, STV0367_ICSPEED_58000, state->config->xtal);
2962 
2963 	msleep(50);
2964 	/* PLL enabled and used */
2965 	stv0367_writereg(state, R367TER_ANACTRL, 0x00);
2966 
2967 	state->cab_state->mclk = stv0367cab_get_mclk(&state->fe,
2968 		state->config->xtal);
2969 	state->cab_state->adc_clk = stv0367cab_get_adc_freq(&state->fe,
2970 		state->config->xtal);
2971 
2972 	state->activedemod = demod_cab;
2973 }
2974 
2975 static int stv0367ddb_set_frontend(struct dvb_frontend *fe)
2976 {
2977 	struct stv0367_state *state = fe->demodulator_priv;
2978 
2979 	switch (fe->dtv_property_cache.delivery_system) {
2980 	case SYS_DVBT:
2981 		if (state->activedemod != demod_ter)
2982 			stv0367ddb_setup_ter(state);
2983 
2984 		return stv0367ter_set_frontend(fe);
2985 	case SYS_DVBC_ANNEX_A:
2986 		if (state->activedemod != demod_cab)
2987 			stv0367ddb_setup_cab(state);
2988 
2989 		/* protect against division error oopses */
2990 		if (fe->dtv_property_cache.symbol_rate == 0) {
2991 			printk(KERN_ERR "Invalid symbol rate\n");
2992 			return -EINVAL;
2993 		}
2994 
2995 		return stv0367cab_set_frontend(fe);
2996 	default:
2997 		break;
2998 	}
2999 
3000 	return -EINVAL;
3001 }
3002 
3003 static void stv0367ddb_read_signal_strength(struct dvb_frontend *fe)
3004 {
3005 	struct stv0367_state *state = fe->demodulator_priv;
3006 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3007 	s32 signalstrength;
3008 
3009 	switch (state->activedemod) {
3010 	case demod_cab:
3011 		signalstrength = stv0367cab_get_rf_lvl(state) * 1000;
3012 		break;
3013 	default:
3014 		p->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3015 		return;
3016 	}
3017 
3018 	p->strength.stat[0].scale = FE_SCALE_DECIBEL;
3019 	p->strength.stat[0].uvalue = signalstrength;
3020 }
3021 
3022 static void stv0367ddb_read_snr(struct dvb_frontend *fe)
3023 {
3024 	struct stv0367_state *state = fe->demodulator_priv;
3025 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3026 	int cab_pwr;
3027 	u32 regval, tmpval, snrval = 0;
3028 
3029 	switch (state->activedemod) {
3030 	case demod_ter:
3031 		snrval = stv0367ter_snr_readreg(fe);
3032 		break;
3033 	case demod_cab:
3034 		cab_pwr = stv0367cab_snr_power(fe);
3035 		regval = stv0367cab_snr_readreg(fe, 0);
3036 
3037 		/* prevent division by zero */
3038 		if (!regval) {
3039 			snrval = 0;
3040 			break;
3041 		}
3042 
3043 		tmpval = (cab_pwr * 320) / regval;
3044 		snrval = ((tmpval != 0) ? (intlog2(tmpval) / 5581) : 0);
3045 		break;
3046 	default:
3047 		p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3048 		return;
3049 	}
3050 
3051 	p->cnr.stat[0].scale = FE_SCALE_DECIBEL;
3052 	p->cnr.stat[0].uvalue = snrval;
3053 }
3054 
3055 static void stv0367ddb_read_ucblocks(struct dvb_frontend *fe)
3056 {
3057 	struct stv0367_state *state = fe->demodulator_priv;
3058 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3059 	u32 ucblocks = 0;
3060 
3061 	switch (state->activedemod) {
3062 	case demod_ter:
3063 		stv0367ter_read_ucblocks(fe, &ucblocks);
3064 		break;
3065 	case demod_cab:
3066 		stv0367cab_read_ucblcks(fe, &ucblocks);
3067 		break;
3068 	default:
3069 		p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3070 		return;
3071 	}
3072 
3073 	p->block_error.stat[0].scale = FE_SCALE_COUNTER;
3074 	p->block_error.stat[0].uvalue = ucblocks;
3075 }
3076 
3077 static int stv0367ddb_read_status(struct dvb_frontend *fe,
3078 				  enum fe_status *status)
3079 {
3080 	struct stv0367_state *state = fe->demodulator_priv;
3081 	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
3082 	int ret = 0;
3083 
3084 	switch (state->activedemod) {
3085 	case demod_ter:
3086 		ret = stv0367ter_read_status(fe, status);
3087 		break;
3088 	case demod_cab:
3089 		ret = stv0367cab_read_status(fe, status);
3090 		break;
3091 	default:
3092 		break;
3093 	}
3094 
3095 	/* stop and report on *_read_status failure */
3096 	if (ret)
3097 		return ret;
3098 
3099 	stv0367ddb_read_signal_strength(fe);
3100 
3101 	/* read carrier/noise when a carrier is detected */
3102 	if (*status & FE_HAS_CARRIER)
3103 		stv0367ddb_read_snr(fe);
3104 	else
3105 		p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3106 
3107 	/* read uncorrected blocks on FE_HAS_LOCK */
3108 	if (*status & FE_HAS_LOCK)
3109 		stv0367ddb_read_ucblocks(fe);
3110 	else
3111 		p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3112 
3113 	return 0;
3114 }
3115 
3116 static int stv0367ddb_get_frontend(struct dvb_frontend *fe,
3117 				   struct dtv_frontend_properties *p)
3118 {
3119 	struct stv0367_state *state = fe->demodulator_priv;
3120 
3121 	switch (state->activedemod) {
3122 	case demod_ter:
3123 		return stv0367ter_get_frontend(fe, p);
3124 	case demod_cab:
3125 		return stv0367cab_get_frontend(fe, p);
3126 	default:
3127 		break;
3128 	}
3129 
3130 	return 0;
3131 }
3132 
3133 static int stv0367ddb_sleep(struct dvb_frontend *fe)
3134 {
3135 	struct stv0367_state *state = fe->demodulator_priv;
3136 
3137 	switch (state->activedemod) {
3138 	case demod_ter:
3139 		state->activedemod = demod_none;
3140 		return stv0367ter_sleep(fe);
3141 	case demod_cab:
3142 		state->activedemod = demod_none;
3143 		return stv0367cab_sleep(fe);
3144 	default:
3145 		break;
3146 	}
3147 
3148 	return -EINVAL;
3149 }
3150 
3151 static int stv0367ddb_init(struct stv0367_state *state)
3152 {
3153 	struct stv0367ter_state *ter_state = state->ter_state;
3154 	struct dtv_frontend_properties *p = &state->fe.dtv_property_cache;
3155 
3156 	stv0367_writereg(state, R367TER_TOPCTRL, 0x10);
3157 
3158 	if (stv0367_deftabs[state->deftabs][STV0367_TAB_BASE])
3159 		stv0367_write_table(state,
3160 			stv0367_deftabs[state->deftabs][STV0367_TAB_BASE]);
3161 
3162 	stv0367_write_table(state,
3163 		stv0367_deftabs[state->deftabs][STV0367_TAB_CAB]);
3164 
3165 	stv0367_writereg(state, R367TER_TOPCTRL, 0x00);
3166 	stv0367_write_table(state,
3167 		stv0367_deftabs[state->deftabs][STV0367_TAB_TER]);
3168 
3169 	stv0367_writereg(state, R367TER_GAIN_SRC1, 0x2A);
3170 	stv0367_writereg(state, R367TER_GAIN_SRC2, 0xD6);
3171 	stv0367_writereg(state, R367TER_INC_DEROT1, 0x55);
3172 	stv0367_writereg(state, R367TER_INC_DEROT2, 0x55);
3173 	stv0367_writereg(state, R367TER_TRL_CTL, 0x14);
3174 	stv0367_writereg(state, R367TER_TRL_NOMRATE1, 0xAE);
3175 	stv0367_writereg(state, R367TER_TRL_NOMRATE2, 0x56);
3176 	stv0367_writereg(state, R367TER_FEPATH_CFG, 0x0);
3177 
3178 	/* OFDM TS Setup */
3179 
3180 	stv0367_writereg(state, R367TER_TSCFGH, 0x70);
3181 	stv0367_writereg(state, R367TER_TSCFGM, 0xC0);
3182 	stv0367_writereg(state, R367TER_TSCFGL, 0x20);
3183 	stv0367_writereg(state, R367TER_TSSPEED, 0x40); /* Fixed at 54 MHz */
3184 
3185 	stv0367_writereg(state, R367TER_TSCFGH, 0x71);
3186 	stv0367_writereg(state, R367TER_TSCFGH, 0x70);
3187 
3188 	stv0367_writereg(state, R367TER_TOPCTRL, 0x10);
3189 
3190 	/* Also needed for QAM */
3191 	stv0367_writereg(state, R367TER_AGC12C, 0x01); /* AGC Pin setup */
3192 
3193 	stv0367_writereg(state, R367TER_AGCCTRL1, 0x8A);
3194 
3195 	/* QAM TS setup, note exact format also depends on descrambler */
3196 	/* settings */
3197 	/* Inverted Clock, Swap, serial */
3198 	stv0367_writereg(state, R367CAB_OUTFORMAT_0, 0x85);
3199 
3200 	/* Clock setup (PLL bypassed and disabled) */
3201 	stv0367_writereg(state, R367TER_ANACTRL, 0x0D);
3202 
3203 	/* IC runs at 58 MHz with a 27 MHz crystal */
3204 	stv0367_pll_setup(state, STV0367_ICSPEED_58000, state->config->xtal);
3205 
3206 	/* Tuner setup */
3207 	/* Buffer Q disabled, I Enabled, signed ADC */
3208 	stv0367_writereg(state, R367TER_ANADIGCTRL, 0x8b);
3209 	stv0367_writereg(state, R367TER_DUAL_AD12, 0x04); /* ADCQ disabled */
3210 
3211 	/* Improves the C/N lock limit */
3212 	stv0367_writereg(state, R367CAB_FSM_SNR2_HTH, 0x23);
3213 	/* ZIF/IF Automatic mode */
3214 	stv0367_writereg(state, R367CAB_IQ_QAM, 0x01);
3215 	/* Improving burst noise performances */
3216 	stv0367_writereg(state, R367CAB_EQU_FFE_LEAKAGE, 0x83);
3217 	/* Improving ACI performances */
3218 	stv0367_writereg(state, R367CAB_IQDEM_ADJ_EN, 0x05);
3219 
3220 	/* PLL enabled and used */
3221 	stv0367_writereg(state, R367TER_ANACTRL, 0x00);
3222 
3223 	stv0367_writereg(state, R367TER_I2CRPT, (0x08 | ((5 & 0x07) << 4)));
3224 
3225 	ter_state->pBER = 0;
3226 	ter_state->first_lock = 0;
3227 	ter_state->unlock_counter = 2;
3228 
3229 	p->strength.len = 1;
3230 	p->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3231 	p->cnr.len = 1;
3232 	p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3233 	p->block_error.len = 1;
3234 	p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
3235 
3236 	return 0;
3237 }
3238 
3239 static const struct dvb_frontend_ops stv0367ddb_ops = {
3240 	.delsys = { SYS_DVBC_ANNEX_A, SYS_DVBT },
3241 	.info = {
3242 		.name			= "ST STV0367 DDB DVB-C/T",
3243 		.frequency_min_hz	=  47 * MHz,
3244 		.frequency_max_hz	= 865 * MHz,
3245 		.frequency_stepsize_hz	= 166667,
3246 		.symbol_rate_min	= 870000,
3247 		.symbol_rate_max	= 11700000,
3248 		.caps = /* DVB-C */
3249 			0x400 |/* FE_CAN_QAM_4 */
3250 			FE_CAN_QAM_16 | FE_CAN_QAM_32  |
3251 			FE_CAN_QAM_64 | FE_CAN_QAM_128 |
3252 			FE_CAN_QAM_256 |
3253 			/* DVB-T */
3254 			FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
3255 			FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
3256 			FE_CAN_QPSK | FE_CAN_TRANSMISSION_MODE_AUTO |
3257 			FE_CAN_RECOVER | FE_CAN_INVERSION_AUTO |
3258 			FE_CAN_MUTE_TS
3259 	},
3260 	.release = stv0367_release,
3261 	.sleep = stv0367ddb_sleep,
3262 	.i2c_gate_ctrl = stv0367cab_gate_ctrl, /* valid for TER and CAB */
3263 	.set_frontend = stv0367ddb_set_frontend,
3264 	.get_frontend = stv0367ddb_get_frontend,
3265 	.get_tune_settings = stv0367_get_tune_settings,
3266 	.read_status = stv0367ddb_read_status,
3267 };
3268 
3269 struct dvb_frontend *stv0367ddb_attach(const struct stv0367_config *config,
3270 				   struct i2c_adapter *i2c)
3271 {
3272 	struct stv0367_state *state = NULL;
3273 	struct stv0367ter_state *ter_state = NULL;
3274 	struct stv0367cab_state *cab_state = NULL;
3275 
3276 	/* allocate memory for the internal state */
3277 	state = kzalloc(sizeof(struct stv0367_state), GFP_KERNEL);
3278 	if (state == NULL)
3279 		goto error;
3280 	ter_state = kzalloc(sizeof(struct stv0367ter_state), GFP_KERNEL);
3281 	if (ter_state == NULL)
3282 		goto error;
3283 	cab_state = kzalloc(sizeof(struct stv0367cab_state), GFP_KERNEL);
3284 	if (cab_state == NULL)
3285 		goto error;
3286 
3287 	/* setup the state */
3288 	state->i2c = i2c;
3289 	state->config = config;
3290 	state->ter_state = ter_state;
3291 	cab_state->search_range = 280000;
3292 	cab_state->qamfec_status_reg = F367CAB_DESCR_SYNCSTATE;
3293 	state->cab_state = cab_state;
3294 	state->fe.ops = stv0367ddb_ops;
3295 	state->fe.demodulator_priv = state;
3296 	state->chip_id = stv0367_readreg(state, R367TER_ID);
3297 
3298 	/* demod operation options */
3299 	state->use_i2c_gatectrl = 0;
3300 	state->deftabs = STV0367_DEFTAB_DDB;
3301 	state->reinit_on_setfrontend = 0;
3302 	state->auto_if_khz = 1;
3303 	state->activedemod = demod_none;
3304 
3305 	dprintk("%s: chip_id = 0x%x\n", __func__, state->chip_id);
3306 
3307 	/* check if the demod is there */
3308 	if ((state->chip_id != 0x50) && (state->chip_id != 0x60))
3309 		goto error;
3310 
3311 	dev_info(&i2c->dev, "Found %s with ChipID %02X at adr %02X\n",
3312 		state->fe.ops.info.name, state->chip_id,
3313 		config->demod_address);
3314 
3315 	stv0367ddb_init(state);
3316 
3317 	return &state->fe;
3318 
3319 error:
3320 	kfree(cab_state);
3321 	kfree(ter_state);
3322 	kfree(state);
3323 	return NULL;
3324 }
3325 EXPORT_SYMBOL_GPL(stv0367ddb_attach);
3326 
3327 MODULE_PARM_DESC(debug, "Set debug");
3328 MODULE_PARM_DESC(i2c_debug, "Set i2c debug");
3329 
3330 MODULE_AUTHOR("Igor M. Liplianin");
3331 MODULE_DESCRIPTION("ST STV0367 DVB-C/T demodulator driver");
3332 MODULE_LICENSE("GPL");
3333