1 // SPDX-License-Identifier: GPL-2.0-or-later
2   /*
3      Driver for Philips tda1004xh OFDM Demodulator
4 
5      (c) 2003, 2004 Andrew de Quincey & Robert Schlabbach
6 
7 
8    */
9 /*
10  * This driver needs external firmware. Please use the commands
11  * "<kerneldir>/scripts/get_dvb_firmware tda10045",
12  * "<kerneldir>/scripts/get_dvb_firmware tda10046" to
13  * download/extract them, and then copy them to /usr/lib/hotplug/firmware
14  * or /lib/firmware (depending on configuration of firmware hotplug).
15  */
16 #define TDA10045_DEFAULT_FIRMWARE "dvb-fe-tda10045.fw"
17 #define TDA10046_DEFAULT_FIRMWARE "dvb-fe-tda10046.fw"
18 
19 #include <linux/init.h>
20 #include <linux/module.h>
21 #include <linux/device.h>
22 #include <linux/jiffies.h>
23 #include <linux/string.h>
24 #include <linux/slab.h>
25 
26 #include <media/dvb_frontend.h>
27 #include "tda1004x.h"
28 
29 static int debug;
30 #define dprintk(args...) \
31 	do { \
32 		if (debug) printk(KERN_DEBUG "tda1004x: " args); \
33 	} while (0)
34 
35 #define TDA1004X_CHIPID		 0x00
36 #define TDA1004X_AUTO		 0x01
37 #define TDA1004X_IN_CONF1	 0x02
38 #define TDA1004X_IN_CONF2	 0x03
39 #define TDA1004X_OUT_CONF1	 0x04
40 #define TDA1004X_OUT_CONF2	 0x05
41 #define TDA1004X_STATUS_CD	 0x06
42 #define TDA1004X_CONFC4		 0x07
43 #define TDA1004X_DSSPARE2	 0x0C
44 #define TDA10045H_CODE_IN	 0x0D
45 #define TDA10045H_FWPAGE	 0x0E
46 #define TDA1004X_SCAN_CPT	 0x10
47 #define TDA1004X_DSP_CMD	 0x11
48 #define TDA1004X_DSP_ARG	 0x12
49 #define TDA1004X_DSP_DATA1	 0x13
50 #define TDA1004X_DSP_DATA2	 0x14
51 #define TDA1004X_CONFADC1	 0x15
52 #define TDA1004X_CONFC1		 0x16
53 #define TDA10045H_S_AGC		 0x1a
54 #define TDA10046H_AGC_TUN_LEVEL	 0x1a
55 #define TDA1004X_SNR		 0x1c
56 #define TDA1004X_CONF_TS1	 0x1e
57 #define TDA1004X_CONF_TS2	 0x1f
58 #define TDA1004X_CBER_RESET	 0x20
59 #define TDA1004X_CBER_MSB	 0x21
60 #define TDA1004X_CBER_LSB	 0x22
61 #define TDA1004X_CVBER_LUT	 0x23
62 #define TDA1004X_VBER_MSB	 0x24
63 #define TDA1004X_VBER_MID	 0x25
64 #define TDA1004X_VBER_LSB	 0x26
65 #define TDA1004X_UNCOR		 0x27
66 
67 #define TDA10045H_CONFPLL_P	 0x2D
68 #define TDA10045H_CONFPLL_M_MSB	 0x2E
69 #define TDA10045H_CONFPLL_M_LSB	 0x2F
70 #define TDA10045H_CONFPLL_N	 0x30
71 
72 #define TDA10046H_CONFPLL1	 0x2D
73 #define TDA10046H_CONFPLL2	 0x2F
74 #define TDA10046H_CONFPLL3	 0x30
75 #define TDA10046H_TIME_WREF1	 0x31
76 #define TDA10046H_TIME_WREF2	 0x32
77 #define TDA10046H_TIME_WREF3	 0x33
78 #define TDA10046H_TIME_WREF4	 0x34
79 #define TDA10046H_TIME_WREF5	 0x35
80 
81 #define TDA10045H_UNSURW_MSB	 0x31
82 #define TDA10045H_UNSURW_LSB	 0x32
83 #define TDA10045H_WREF_MSB	 0x33
84 #define TDA10045H_WREF_MID	 0x34
85 #define TDA10045H_WREF_LSB	 0x35
86 #define TDA10045H_MUXOUT	 0x36
87 #define TDA1004X_CONFADC2	 0x37
88 
89 #define TDA10045H_IOFFSET	 0x38
90 
91 #define TDA10046H_CONF_TRISTATE1 0x3B
92 #define TDA10046H_CONF_TRISTATE2 0x3C
93 #define TDA10046H_CONF_POLARITY	 0x3D
94 #define TDA10046H_FREQ_OFFSET	 0x3E
95 #define TDA10046H_GPIO_OUT_SEL	 0x41
96 #define TDA10046H_GPIO_SELECT	 0x42
97 #define TDA10046H_AGC_CONF	 0x43
98 #define TDA10046H_AGC_THR	 0x44
99 #define TDA10046H_AGC_RENORM	 0x45
100 #define TDA10046H_AGC_GAINS	 0x46
101 #define TDA10046H_AGC_TUN_MIN	 0x47
102 #define TDA10046H_AGC_TUN_MAX	 0x48
103 #define TDA10046H_AGC_IF_MIN	 0x49
104 #define TDA10046H_AGC_IF_MAX	 0x4A
105 
106 #define TDA10046H_FREQ_PHY2_MSB	 0x4D
107 #define TDA10046H_FREQ_PHY2_LSB	 0x4E
108 
109 #define TDA10046H_CVBER_CTRL	 0x4F
110 #define TDA10046H_AGC_IF_LEVEL	 0x52
111 #define TDA10046H_CODE_CPT	 0x57
112 #define TDA10046H_CODE_IN	 0x58
113 
114 
115 static int tda1004x_write_byteI(struct tda1004x_state *state, int reg, int data)
116 {
117 	int ret;
118 	u8 buf[] = { reg, data };
119 	struct i2c_msg msg = { .flags = 0, .buf = buf, .len = 2 };
120 
121 	dprintk("%s: reg=0x%x, data=0x%x\n", __func__, reg, data);
122 
123 	msg.addr = state->config->demod_address;
124 	ret = i2c_transfer(state->i2c, &msg, 1);
125 
126 	if (ret != 1)
127 		dprintk("%s: error reg=0x%x, data=0x%x, ret=%i\n",
128 			__func__, reg, data, ret);
129 
130 	dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __func__,
131 		reg, data, ret);
132 	return (ret != 1) ? -1 : 0;
133 }
134 
135 static int tda1004x_read_byte(struct tda1004x_state *state, int reg)
136 {
137 	int ret;
138 	u8 b0[] = { reg };
139 	u8 b1[] = { 0 };
140 	struct i2c_msg msg[] = {{ .flags = 0, .buf = b0, .len = 1 },
141 				{ .flags = I2C_M_RD, .buf = b1, .len = 1 }};
142 
143 	dprintk("%s: reg=0x%x\n", __func__, reg);
144 
145 	msg[0].addr = state->config->demod_address;
146 	msg[1].addr = state->config->demod_address;
147 	ret = i2c_transfer(state->i2c, msg, 2);
148 
149 	if (ret != 2) {
150 		dprintk("%s: error reg=0x%x, ret=%i\n", __func__, reg,
151 			ret);
152 		return -EINVAL;
153 	}
154 
155 	dprintk("%s: success reg=0x%x, data=0x%x, ret=%i\n", __func__,
156 		reg, b1[0], ret);
157 	return b1[0];
158 }
159 
160 static int tda1004x_write_mask(struct tda1004x_state *state, int reg, int mask, int data)
161 {
162 	int val;
163 	dprintk("%s: reg=0x%x, mask=0x%x, data=0x%x\n", __func__, reg,
164 		mask, data);
165 
166 	// read a byte and check
167 	val = tda1004x_read_byte(state, reg);
168 	if (val < 0)
169 		return val;
170 
171 	// mask if off
172 	val = val & ~mask;
173 	val |= data & 0xff;
174 
175 	// write it out again
176 	return tda1004x_write_byteI(state, reg, val);
177 }
178 
179 static int tda1004x_write_buf(struct tda1004x_state *state, int reg, unsigned char *buf, int len)
180 {
181 	int i;
182 	int result;
183 
184 	dprintk("%s: reg=0x%x, len=0x%x\n", __func__, reg, len);
185 
186 	result = 0;
187 	for (i = 0; i < len; i++) {
188 		result = tda1004x_write_byteI(state, reg + i, buf[i]);
189 		if (result != 0)
190 			break;
191 	}
192 
193 	return result;
194 }
195 
196 static int tda1004x_enable_tuner_i2c(struct tda1004x_state *state)
197 {
198 	int result;
199 	dprintk("%s\n", __func__);
200 
201 	result = tda1004x_write_mask(state, TDA1004X_CONFC4, 2, 2);
202 	msleep(20);
203 	return result;
204 }
205 
206 static int tda1004x_disable_tuner_i2c(struct tda1004x_state *state)
207 {
208 	dprintk("%s\n", __func__);
209 
210 	return tda1004x_write_mask(state, TDA1004X_CONFC4, 2, 0);
211 }
212 
213 static int tda10045h_set_bandwidth(struct tda1004x_state *state,
214 				   u32 bandwidth)
215 {
216 	static u8 bandwidth_6mhz[] = { 0x02, 0x00, 0x3d, 0x00, 0x60, 0x1e, 0xa7, 0x45, 0x4f };
217 	static u8 bandwidth_7mhz[] = { 0x02, 0x00, 0x37, 0x00, 0x4a, 0x2f, 0x6d, 0x76, 0xdb };
218 	static u8 bandwidth_8mhz[] = { 0x02, 0x00, 0x3d, 0x00, 0x48, 0x17, 0x89, 0xc7, 0x14 };
219 
220 	switch (bandwidth) {
221 	case 6000000:
222 		tda1004x_write_buf(state, TDA10045H_CONFPLL_P, bandwidth_6mhz, sizeof(bandwidth_6mhz));
223 		break;
224 
225 	case 7000000:
226 		tda1004x_write_buf(state, TDA10045H_CONFPLL_P, bandwidth_7mhz, sizeof(bandwidth_7mhz));
227 		break;
228 
229 	case 8000000:
230 		tda1004x_write_buf(state, TDA10045H_CONFPLL_P, bandwidth_8mhz, sizeof(bandwidth_8mhz));
231 		break;
232 
233 	default:
234 		return -EINVAL;
235 	}
236 
237 	tda1004x_write_byteI(state, TDA10045H_IOFFSET, 0);
238 
239 	return 0;
240 }
241 
242 static int tda10046h_set_bandwidth(struct tda1004x_state *state,
243 				   u32 bandwidth)
244 {
245 	static u8 bandwidth_6mhz_53M[] = { 0x7b, 0x2e, 0x11, 0xf0, 0xd2 };
246 	static u8 bandwidth_7mhz_53M[] = { 0x6a, 0x02, 0x6a, 0x43, 0x9f };
247 	static u8 bandwidth_8mhz_53M[] = { 0x5c, 0x32, 0xc2, 0x96, 0x6d };
248 
249 	static u8 bandwidth_6mhz_48M[] = { 0x70, 0x02, 0x49, 0x24, 0x92 };
250 	static u8 bandwidth_7mhz_48M[] = { 0x60, 0x02, 0xaa, 0xaa, 0xab };
251 	static u8 bandwidth_8mhz_48M[] = { 0x54, 0x03, 0x0c, 0x30, 0xc3 };
252 	int tda10046_clk53m;
253 
254 	if ((state->config->if_freq == TDA10046_FREQ_045) ||
255 	    (state->config->if_freq == TDA10046_FREQ_052))
256 		tda10046_clk53m = 0;
257 	else
258 		tda10046_clk53m = 1;
259 	switch (bandwidth) {
260 	case 6000000:
261 		if (tda10046_clk53m)
262 			tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_6mhz_53M,
263 						  sizeof(bandwidth_6mhz_53M));
264 		else
265 			tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_6mhz_48M,
266 						  sizeof(bandwidth_6mhz_48M));
267 		if (state->config->if_freq == TDA10046_FREQ_045) {
268 			tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0a);
269 			tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0xab);
270 		}
271 		break;
272 
273 	case 7000000:
274 		if (tda10046_clk53m)
275 			tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_7mhz_53M,
276 						  sizeof(bandwidth_7mhz_53M));
277 		else
278 			tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_7mhz_48M,
279 						  sizeof(bandwidth_7mhz_48M));
280 		if (state->config->if_freq == TDA10046_FREQ_045) {
281 			tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0c);
282 			tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x00);
283 		}
284 		break;
285 
286 	case 8000000:
287 		if (tda10046_clk53m)
288 			tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_8mhz_53M,
289 						  sizeof(bandwidth_8mhz_53M));
290 		else
291 			tda1004x_write_buf(state, TDA10046H_TIME_WREF1, bandwidth_8mhz_48M,
292 						  sizeof(bandwidth_8mhz_48M));
293 		if (state->config->if_freq == TDA10046_FREQ_045) {
294 			tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0d);
295 			tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x55);
296 		}
297 		break;
298 
299 	default:
300 		return -EINVAL;
301 	}
302 
303 	return 0;
304 }
305 
306 static int tda1004x_do_upload(struct tda1004x_state *state,
307 			      const unsigned char *mem, unsigned int len,
308 			      u8 dspCodeCounterReg, u8 dspCodeInReg)
309 {
310 	u8 buf[65];
311 	struct i2c_msg fw_msg = { .flags = 0, .buf = buf, .len = 0 };
312 	int tx_size;
313 	int pos = 0;
314 
315 	/* clear code counter */
316 	tda1004x_write_byteI(state, dspCodeCounterReg, 0);
317 	fw_msg.addr = state->config->demod_address;
318 
319 	i2c_lock_bus(state->i2c, I2C_LOCK_SEGMENT);
320 	buf[0] = dspCodeInReg;
321 	while (pos != len) {
322 		// work out how much to send this time
323 		tx_size = len - pos;
324 		if (tx_size > 0x10)
325 			tx_size = 0x10;
326 
327 		// send the chunk
328 		memcpy(buf + 1, mem + pos, tx_size);
329 		fw_msg.len = tx_size + 1;
330 		if (__i2c_transfer(state->i2c, &fw_msg, 1) != 1) {
331 			printk(KERN_ERR "tda1004x: Error during firmware upload\n");
332 			i2c_unlock_bus(state->i2c, I2C_LOCK_SEGMENT);
333 			return -EIO;
334 		}
335 		pos += tx_size;
336 
337 		dprintk("%s: fw_pos=0x%x\n", __func__, pos);
338 	}
339 	i2c_unlock_bus(state->i2c, I2C_LOCK_SEGMENT);
340 
341 	/* give the DSP a chance to settle 03/10/05 Hac */
342 	msleep(100);
343 
344 	return 0;
345 }
346 
347 static int tda1004x_check_upload_ok(struct tda1004x_state *state)
348 {
349 	u8 data1, data2;
350 	unsigned long timeout;
351 
352 	if (state->demod_type == TDA1004X_DEMOD_TDA10046) {
353 		timeout = jiffies + 2 * HZ;
354 		while(!(tda1004x_read_byte(state, TDA1004X_STATUS_CD) & 0x20)) {
355 			if (time_after(jiffies, timeout)) {
356 				printk(KERN_ERR "tda1004x: timeout waiting for DSP ready\n");
357 				break;
358 			}
359 			msleep(1);
360 		}
361 	} else
362 		msleep(100);
363 
364 	// check upload was OK
365 	tda1004x_write_mask(state, TDA1004X_CONFC4, 0x10, 0); // we want to read from the DSP
366 	tda1004x_write_byteI(state, TDA1004X_DSP_CMD, 0x67);
367 
368 	data1 = tda1004x_read_byte(state, TDA1004X_DSP_DATA1);
369 	data2 = tda1004x_read_byte(state, TDA1004X_DSP_DATA2);
370 	if (data1 != 0x67 || data2 < 0x20 || data2 > 0x2e) {
371 		printk(KERN_INFO "tda1004x: found firmware revision %x -- invalid\n", data2);
372 		return -EIO;
373 	}
374 	printk(KERN_INFO "tda1004x: found firmware revision %x -- ok\n", data2);
375 	return 0;
376 }
377 
378 static int tda10045_fwupload(struct dvb_frontend* fe)
379 {
380 	struct tda1004x_state* state = fe->demodulator_priv;
381 	int ret;
382 	const struct firmware *fw;
383 
384 	/* don't re-upload unless necessary */
385 	if (tda1004x_check_upload_ok(state) == 0)
386 		return 0;
387 
388 	/* request the firmware, this will block until someone uploads it */
389 	printk(KERN_INFO "tda1004x: waiting for firmware upload (%s)...\n", TDA10045_DEFAULT_FIRMWARE);
390 	ret = state->config->request_firmware(fe, &fw, TDA10045_DEFAULT_FIRMWARE);
391 	if (ret) {
392 		printk(KERN_ERR "tda1004x: no firmware upload (timeout or file not found?)\n");
393 		return ret;
394 	}
395 
396 	/* reset chip */
397 	tda1004x_write_mask(state, TDA1004X_CONFC4, 0x10, 0);
398 	tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 8);
399 	tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 0);
400 	msleep(10);
401 
402 	/* set parameters */
403 	tda10045h_set_bandwidth(state, 8000000);
404 
405 	ret = tda1004x_do_upload(state, fw->data, fw->size, TDA10045H_FWPAGE, TDA10045H_CODE_IN);
406 	release_firmware(fw);
407 	if (ret)
408 		return ret;
409 	printk(KERN_INFO "tda1004x: firmware upload complete\n");
410 
411 	/* wait for DSP to initialise */
412 	/* DSPREADY doesn't seem to work on the TDA10045H */
413 	msleep(100);
414 
415 	return tda1004x_check_upload_ok(state);
416 }
417 
418 static void tda10046_init_plls(struct dvb_frontend* fe)
419 {
420 	struct tda1004x_state* state = fe->demodulator_priv;
421 	int tda10046_clk53m;
422 
423 	if ((state->config->if_freq == TDA10046_FREQ_045) ||
424 	    (state->config->if_freq == TDA10046_FREQ_052))
425 		tda10046_clk53m = 0;
426 	else
427 		tda10046_clk53m = 1;
428 
429 	tda1004x_write_byteI(state, TDA10046H_CONFPLL1, 0xf0);
430 	if(tda10046_clk53m) {
431 		printk(KERN_INFO "tda1004x: setting up plls for 53MHz sampling clock\n");
432 		tda1004x_write_byteI(state, TDA10046H_CONFPLL2, 0x08); // PLL M = 8
433 	} else {
434 		printk(KERN_INFO "tda1004x: setting up plls for 48MHz sampling clock\n");
435 		tda1004x_write_byteI(state, TDA10046H_CONFPLL2, 0x03); // PLL M = 3
436 	}
437 	if (state->config->xtal_freq == TDA10046_XTAL_4M ) {
438 		dprintk("%s: setting up PLLs for a 4 MHz Xtal\n", __func__);
439 		tda1004x_write_byteI(state, TDA10046H_CONFPLL3, 0); // PLL P = N = 0
440 	} else {
441 		dprintk("%s: setting up PLLs for a 16 MHz Xtal\n", __func__);
442 		tda1004x_write_byteI(state, TDA10046H_CONFPLL3, 3); // PLL P = 0, N = 3
443 	}
444 	if(tda10046_clk53m)
445 		tda1004x_write_byteI(state, TDA10046H_FREQ_OFFSET, 0x67);
446 	else
447 		tda1004x_write_byteI(state, TDA10046H_FREQ_OFFSET, 0x72);
448 	/* Note clock frequency is handled implicitly */
449 	switch (state->config->if_freq) {
450 	case TDA10046_FREQ_045:
451 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0c);
452 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x00);
453 		break;
454 	case TDA10046_FREQ_052:
455 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0x0d);
456 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0xc7);
457 		break;
458 	case TDA10046_FREQ_3617:
459 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0xd7);
460 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x59);
461 		break;
462 	case TDA10046_FREQ_3613:
463 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_MSB, 0xd7);
464 		tda1004x_write_byteI(state, TDA10046H_FREQ_PHY2_LSB, 0x3f);
465 		break;
466 	}
467 	tda10046h_set_bandwidth(state, 8000000); /* default bandwidth 8 MHz */
468 	/* let the PLLs settle */
469 	msleep(120);
470 }
471 
472 static int tda10046_fwupload(struct dvb_frontend* fe)
473 {
474 	struct tda1004x_state* state = fe->demodulator_priv;
475 	int ret, confc4;
476 	const struct firmware *fw;
477 
478 	/* reset + wake up chip */
479 	if (state->config->xtal_freq == TDA10046_XTAL_4M) {
480 		confc4 = 0;
481 	} else {
482 		dprintk("%s: 16MHz Xtal, reducing I2C speed\n", __func__);
483 		confc4 = 0x80;
484 	}
485 	tda1004x_write_byteI(state, TDA1004X_CONFC4, confc4);
486 
487 	tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 1, 0);
488 	/* set GPIO 1 and 3 */
489 	if (state->config->gpio_config != TDA10046_GPTRI) {
490 		tda1004x_write_byteI(state, TDA10046H_CONF_TRISTATE2, 0x33);
491 		tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0x0f, state->config->gpio_config &0x0f);
492 	}
493 	/* let the clocks recover from sleep */
494 	msleep(10);
495 
496 	/* The PLLs need to be reprogrammed after sleep */
497 	tda10046_init_plls(fe);
498 	tda1004x_write_mask(state, TDA1004X_CONFADC2, 0xc0, 0);
499 
500 	/* don't re-upload unless necessary */
501 	if (tda1004x_check_upload_ok(state) == 0)
502 		return 0;
503 
504 	/*
505 	   For i2c normal work, we need to slow down the bus speed.
506 	   However, the slow down breaks the eeprom firmware load.
507 	   So, use normal speed for eeprom booting and then restore the
508 	   i2c speed after that. Tested with MSI TV @nyware A/D board,
509 	   that comes with firmware version 29 inside their eeprom.
510 
511 	   It should also be noticed that no other I2C transfer should
512 	   be in course while booting from eeprom, otherwise, tda10046
513 	   goes into an instable state. So, proper locking are needed
514 	   at the i2c bus master.
515 	 */
516 	printk(KERN_INFO "tda1004x: trying to boot from eeprom\n");
517 	tda1004x_write_byteI(state, TDA1004X_CONFC4, 4);
518 	msleep(300);
519 	tda1004x_write_byteI(state, TDA1004X_CONFC4, confc4);
520 
521 	/* Checks if eeprom firmware went without troubles */
522 	if (tda1004x_check_upload_ok(state) == 0)
523 		return 0;
524 
525 	/* eeprom firmware didn't work. Load one manually. */
526 
527 	if (state->config->request_firmware != NULL) {
528 		/* request the firmware, this will block until someone uploads it */
529 		printk(KERN_INFO "tda1004x: waiting for firmware upload...\n");
530 		ret = state->config->request_firmware(fe, &fw, TDA10046_DEFAULT_FIRMWARE);
531 		if (ret) {
532 			/* remain compatible to old bug: try to load with tda10045 image name */
533 			ret = state->config->request_firmware(fe, &fw, TDA10045_DEFAULT_FIRMWARE);
534 			if (ret) {
535 				printk(KERN_ERR "tda1004x: no firmware upload (timeout or file not found?)\n");
536 				return ret;
537 			} else {
538 				printk(KERN_INFO "tda1004x: please rename the firmware file to %s\n",
539 						  TDA10046_DEFAULT_FIRMWARE);
540 			}
541 		}
542 	} else {
543 		printk(KERN_ERR "tda1004x: no request function defined, can't upload from file\n");
544 		return -EIO;
545 	}
546 	tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 8); // going to boot from HOST
547 	ret = tda1004x_do_upload(state, fw->data, fw->size, TDA10046H_CODE_CPT, TDA10046H_CODE_IN);
548 	release_firmware(fw);
549 	return tda1004x_check_upload_ok(state);
550 }
551 
552 static int tda1004x_encode_fec(int fec)
553 {
554 	// convert known FEC values
555 	switch (fec) {
556 	case FEC_1_2:
557 		return 0;
558 	case FEC_2_3:
559 		return 1;
560 	case FEC_3_4:
561 		return 2;
562 	case FEC_5_6:
563 		return 3;
564 	case FEC_7_8:
565 		return 4;
566 	}
567 
568 	// unsupported
569 	return -EINVAL;
570 }
571 
572 static int tda1004x_decode_fec(int tdafec)
573 {
574 	// convert known FEC values
575 	switch (tdafec) {
576 	case 0:
577 		return FEC_1_2;
578 	case 1:
579 		return FEC_2_3;
580 	case 2:
581 		return FEC_3_4;
582 	case 3:
583 		return FEC_5_6;
584 	case 4:
585 		return FEC_7_8;
586 	}
587 
588 	// unsupported
589 	return -1;
590 }
591 
592 static int tda1004x_write(struct dvb_frontend* fe, const u8 buf[], int len)
593 {
594 	struct tda1004x_state* state = fe->demodulator_priv;
595 
596 	if (len != 2)
597 		return -EINVAL;
598 
599 	return tda1004x_write_byteI(state, buf[0], buf[1]);
600 }
601 
602 static int tda10045_init(struct dvb_frontend* fe)
603 {
604 	struct tda1004x_state* state = fe->demodulator_priv;
605 
606 	dprintk("%s\n", __func__);
607 
608 	if (tda10045_fwupload(fe)) {
609 		printk("tda1004x: firmware upload failed\n");
610 		return -EIO;
611 	}
612 
613 	tda1004x_write_mask(state, TDA1004X_CONFADC1, 0x10, 0); // wake up the ADC
614 
615 	// tda setup
616 	tda1004x_write_mask(state, TDA1004X_CONFC4, 0x20, 0); // disable DSP watchdog timer
617 	tda1004x_write_mask(state, TDA1004X_AUTO, 8, 0); // select HP stream
618 	tda1004x_write_mask(state, TDA1004X_CONFC1, 0x40, 0); // set polarity of VAGC signal
619 	tda1004x_write_mask(state, TDA1004X_CONFC1, 0x80, 0x80); // enable pulse killer
620 	tda1004x_write_mask(state, TDA1004X_AUTO, 0x10, 0x10); // enable auto offset
621 	tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0xC0, 0x0); // no frequency offset
622 	tda1004x_write_byteI(state, TDA1004X_CONF_TS1, 0); // setup MPEG2 TS interface
623 	tda1004x_write_byteI(state, TDA1004X_CONF_TS2, 0); // setup MPEG2 TS interface
624 	tda1004x_write_mask(state, TDA1004X_VBER_MSB, 0xe0, 0xa0); // 10^6 VBER measurement bits
625 	tda1004x_write_mask(state, TDA1004X_CONFC1, 0x10, 0); // VAGC polarity
626 	tda1004x_write_byteI(state, TDA1004X_CONFADC1, 0x2e);
627 
628 	tda1004x_write_mask(state, 0x1f, 0x01, state->config->invert_oclk);
629 
630 	return 0;
631 }
632 
633 static int tda10046_init(struct dvb_frontend* fe)
634 {
635 	struct tda1004x_state* state = fe->demodulator_priv;
636 	dprintk("%s\n", __func__);
637 
638 	if (tda10046_fwupload(fe)) {
639 		printk("tda1004x: firmware upload failed\n");
640 		return -EIO;
641 	}
642 
643 	// tda setup
644 	tda1004x_write_mask(state, TDA1004X_CONFC4, 0x20, 0); // disable DSP watchdog timer
645 	tda1004x_write_byteI(state, TDA1004X_AUTO, 0x87);    // 100 ppm crystal, select HP stream
646 	tda1004x_write_byteI(state, TDA1004X_CONFC1, 0x88);      // enable pulse killer
647 
648 	switch (state->config->agc_config) {
649 	case TDA10046_AGC_DEFAULT:
650 		tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x00); // AGC setup
651 		tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x60);  // set AGC polarities
652 		break;
653 	case TDA10046_AGC_IFO_AUTO_NEG:
654 		tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x0a); // AGC setup
655 		tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x60);  // set AGC polarities
656 		break;
657 	case TDA10046_AGC_IFO_AUTO_POS:
658 		tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x0a); // AGC setup
659 		tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x00);  // set AGC polarities
660 		break;
661 	case TDA10046_AGC_TDA827X:
662 		tda1004x_write_byteI(state, TDA10046H_AGC_CONF, 0x02);   // AGC setup
663 		tda1004x_write_byteI(state, TDA10046H_AGC_THR, 0x70);    // AGC Threshold
664 		tda1004x_write_byteI(state, TDA10046H_AGC_RENORM, 0x08); // Gain Renormalize
665 		tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0xf0, 0x60);  // set AGC polarities
666 		break;
667 	}
668 	if (state->config->ts_mode == 0) {
669 		tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 0xc0, 0x40);
670 		tda1004x_write_mask(state, 0x3a, 0x80, state->config->invert_oclk << 7);
671 	} else {
672 		tda1004x_write_mask(state, TDA10046H_CONF_TRISTATE1, 0xc0, 0x80);
673 		tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0x10,
674 							state->config->invert_oclk << 4);
675 	}
676 	tda1004x_write_byteI(state, TDA1004X_CONFADC2, 0x38);
677 	tda1004x_write_mask (state, TDA10046H_CONF_TRISTATE1, 0x3e, 0x38); // Turn IF AGC output on
678 	tda1004x_write_byteI(state, TDA10046H_AGC_TUN_MIN, 0);	  // }
679 	tda1004x_write_byteI(state, TDA10046H_AGC_TUN_MAX, 0xff); // } AGC min/max values
680 	tda1004x_write_byteI(state, TDA10046H_AGC_IF_MIN, 0);	  // }
681 	tda1004x_write_byteI(state, TDA10046H_AGC_IF_MAX, 0xff);  // }
682 	tda1004x_write_byteI(state, TDA10046H_AGC_GAINS, 0x12); // IF gain 2, TUN gain 1
683 	tda1004x_write_byteI(state, TDA10046H_CVBER_CTRL, 0x1a); // 10^6 VBER measurement bits
684 	tda1004x_write_byteI(state, TDA1004X_CONF_TS1, 7); // MPEG2 interface config
685 	tda1004x_write_byteI(state, TDA1004X_CONF_TS2, 0xc0); // MPEG2 interface config
686 	// tda1004x_write_mask(state, 0x50, 0x80, 0x80);         // handle out of guard echoes
687 
688 	return 0;
689 }
690 
691 static int tda1004x_set_fe(struct dvb_frontend *fe)
692 {
693 	struct dtv_frontend_properties *fe_params = &fe->dtv_property_cache;
694 	struct tda1004x_state* state = fe->demodulator_priv;
695 	int tmp;
696 	int inversion;
697 
698 	dprintk("%s\n", __func__);
699 
700 	if (state->demod_type == TDA1004X_DEMOD_TDA10046) {
701 		// setup auto offset
702 		tda1004x_write_mask(state, TDA1004X_AUTO, 0x10, 0x10);
703 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x80, 0);
704 		tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0xC0, 0);
705 
706 		// disable agc_conf[2]
707 		tda1004x_write_mask(state, TDA10046H_AGC_CONF, 4, 0);
708 	}
709 
710 	// set frequency
711 	if (fe->ops.tuner_ops.set_params) {
712 		fe->ops.tuner_ops.set_params(fe);
713 		if (fe->ops.i2c_gate_ctrl)
714 			fe->ops.i2c_gate_ctrl(fe, 0);
715 	}
716 
717 	// Hardcoded to use auto as much as possible on the TDA10045 as it
718 	// is very unreliable if AUTO mode is _not_ used.
719 	if (state->demod_type == TDA1004X_DEMOD_TDA10045) {
720 		fe_params->code_rate_HP = FEC_AUTO;
721 		fe_params->guard_interval = GUARD_INTERVAL_AUTO;
722 		fe_params->transmission_mode = TRANSMISSION_MODE_AUTO;
723 	}
724 
725 	// Set standard params.. or put them to auto
726 	if ((fe_params->code_rate_HP == FEC_AUTO) ||
727 		(fe_params->code_rate_LP == FEC_AUTO) ||
728 		(fe_params->modulation == QAM_AUTO) ||
729 		(fe_params->hierarchy == HIERARCHY_AUTO)) {
730 		tda1004x_write_mask(state, TDA1004X_AUTO, 1, 1);	// enable auto
731 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x03, 0);	/* turn off modulation bits */
732 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 0);	// turn off hierarchy bits
733 		tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0x3f, 0);	// turn off FEC bits
734 	} else {
735 		tda1004x_write_mask(state, TDA1004X_AUTO, 1, 0);	// disable auto
736 
737 		// set HP FEC
738 		tmp = tda1004x_encode_fec(fe_params->code_rate_HP);
739 		if (tmp < 0)
740 			return tmp;
741 		tda1004x_write_mask(state, TDA1004X_IN_CONF2, 7, tmp);
742 
743 		// set LP FEC
744 		tmp = tda1004x_encode_fec(fe_params->code_rate_LP);
745 		if (tmp < 0)
746 			return tmp;
747 		tda1004x_write_mask(state, TDA1004X_IN_CONF2, 0x38, tmp << 3);
748 
749 		/* set modulation */
750 		switch (fe_params->modulation) {
751 		case QPSK:
752 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 3, 0);
753 			break;
754 
755 		case QAM_16:
756 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 3, 1);
757 			break;
758 
759 		case QAM_64:
760 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 3, 2);
761 			break;
762 
763 		default:
764 			return -EINVAL;
765 		}
766 
767 		// set hierarchy
768 		switch (fe_params->hierarchy) {
769 		case HIERARCHY_NONE:
770 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 0 << 5);
771 			break;
772 
773 		case HIERARCHY_1:
774 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 1 << 5);
775 			break;
776 
777 		case HIERARCHY_2:
778 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 2 << 5);
779 			break;
780 
781 		case HIERARCHY_4:
782 			tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x60, 3 << 5);
783 			break;
784 
785 		default:
786 			return -EINVAL;
787 		}
788 	}
789 
790 	// set bandwidth
791 	switch (state->demod_type) {
792 	case TDA1004X_DEMOD_TDA10045:
793 		tda10045h_set_bandwidth(state, fe_params->bandwidth_hz);
794 		break;
795 
796 	case TDA1004X_DEMOD_TDA10046:
797 		tda10046h_set_bandwidth(state, fe_params->bandwidth_hz);
798 		break;
799 	}
800 
801 	// set inversion
802 	inversion = fe_params->inversion;
803 	if (state->config->invert)
804 		inversion = inversion ? INVERSION_OFF : INVERSION_ON;
805 	switch (inversion) {
806 	case INVERSION_OFF:
807 		tda1004x_write_mask(state, TDA1004X_CONFC1, 0x20, 0);
808 		break;
809 
810 	case INVERSION_ON:
811 		tda1004x_write_mask(state, TDA1004X_CONFC1, 0x20, 0x20);
812 		break;
813 
814 	default:
815 		return -EINVAL;
816 	}
817 
818 	// set guard interval
819 	switch (fe_params->guard_interval) {
820 	case GUARD_INTERVAL_1_32:
821 		tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
822 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 0 << 2);
823 		break;
824 
825 	case GUARD_INTERVAL_1_16:
826 		tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
827 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 1 << 2);
828 		break;
829 
830 	case GUARD_INTERVAL_1_8:
831 		tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
832 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 2 << 2);
833 		break;
834 
835 	case GUARD_INTERVAL_1_4:
836 		tda1004x_write_mask(state, TDA1004X_AUTO, 2, 0);
837 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 3 << 2);
838 		break;
839 
840 	case GUARD_INTERVAL_AUTO:
841 		tda1004x_write_mask(state, TDA1004X_AUTO, 2, 2);
842 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x0c, 0 << 2);
843 		break;
844 
845 	default:
846 		return -EINVAL;
847 	}
848 
849 	// set transmission mode
850 	switch (fe_params->transmission_mode) {
851 	case TRANSMISSION_MODE_2K:
852 		tda1004x_write_mask(state, TDA1004X_AUTO, 4, 0);
853 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x10, 0 << 4);
854 		break;
855 
856 	case TRANSMISSION_MODE_8K:
857 		tda1004x_write_mask(state, TDA1004X_AUTO, 4, 0);
858 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x10, 1 << 4);
859 		break;
860 
861 	case TRANSMISSION_MODE_AUTO:
862 		tda1004x_write_mask(state, TDA1004X_AUTO, 4, 4);
863 		tda1004x_write_mask(state, TDA1004X_IN_CONF1, 0x10, 0);
864 		break;
865 
866 	default:
867 		return -EINVAL;
868 	}
869 
870 	// start the lock
871 	switch (state->demod_type) {
872 	case TDA1004X_DEMOD_TDA10045:
873 		tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 8);
874 		tda1004x_write_mask(state, TDA1004X_CONFC4, 8, 0);
875 		break;
876 
877 	case TDA1004X_DEMOD_TDA10046:
878 		tda1004x_write_mask(state, TDA1004X_AUTO, 0x40, 0x40);
879 		msleep(1);
880 		tda1004x_write_mask(state, TDA10046H_AGC_CONF, 4, 1);
881 		break;
882 	}
883 
884 	msleep(10);
885 
886 	return 0;
887 }
888 
889 static int tda1004x_get_fe(struct dvb_frontend *fe,
890 			   struct dtv_frontend_properties *fe_params)
891 {
892 	struct tda1004x_state* state = fe->demodulator_priv;
893 	int status;
894 
895 	dprintk("%s\n", __func__);
896 
897 	status = tda1004x_read_byte(state, TDA1004X_STATUS_CD);
898 	if (status == -1)
899 		return -EIO;
900 
901 	/* Only update the properties cache if device is locked */
902 	if (!(status & 8))
903 		return 0;
904 
905 	// inversion status
906 	fe_params->inversion = INVERSION_OFF;
907 	if (tda1004x_read_byte(state, TDA1004X_CONFC1) & 0x20)
908 		fe_params->inversion = INVERSION_ON;
909 	if (state->config->invert)
910 		fe_params->inversion = fe_params->inversion ? INVERSION_OFF : INVERSION_ON;
911 
912 	// bandwidth
913 	switch (state->demod_type) {
914 	case TDA1004X_DEMOD_TDA10045:
915 		switch (tda1004x_read_byte(state, TDA10045H_WREF_LSB)) {
916 		case 0x14:
917 			fe_params->bandwidth_hz = 8000000;
918 			break;
919 		case 0xdb:
920 			fe_params->bandwidth_hz = 7000000;
921 			break;
922 		case 0x4f:
923 			fe_params->bandwidth_hz = 6000000;
924 			break;
925 		}
926 		break;
927 	case TDA1004X_DEMOD_TDA10046:
928 		switch (tda1004x_read_byte(state, TDA10046H_TIME_WREF1)) {
929 		case 0x5c:
930 		case 0x54:
931 			fe_params->bandwidth_hz = 8000000;
932 			break;
933 		case 0x6a:
934 		case 0x60:
935 			fe_params->bandwidth_hz = 7000000;
936 			break;
937 		case 0x7b:
938 		case 0x70:
939 			fe_params->bandwidth_hz = 6000000;
940 			break;
941 		}
942 		break;
943 	}
944 
945 	// FEC
946 	fe_params->code_rate_HP =
947 	    tda1004x_decode_fec(tda1004x_read_byte(state, TDA1004X_OUT_CONF2) & 7);
948 	fe_params->code_rate_LP =
949 	    tda1004x_decode_fec((tda1004x_read_byte(state, TDA1004X_OUT_CONF2) >> 3) & 7);
950 
951 	/* modulation */
952 	switch (tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 3) {
953 	case 0:
954 		fe_params->modulation = QPSK;
955 		break;
956 	case 1:
957 		fe_params->modulation = QAM_16;
958 		break;
959 	case 2:
960 		fe_params->modulation = QAM_64;
961 		break;
962 	}
963 
964 	// transmission mode
965 	fe_params->transmission_mode = TRANSMISSION_MODE_2K;
966 	if (tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 0x10)
967 		fe_params->transmission_mode = TRANSMISSION_MODE_8K;
968 
969 	// guard interval
970 	switch ((tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 0x0c) >> 2) {
971 	case 0:
972 		fe_params->guard_interval = GUARD_INTERVAL_1_32;
973 		break;
974 	case 1:
975 		fe_params->guard_interval = GUARD_INTERVAL_1_16;
976 		break;
977 	case 2:
978 		fe_params->guard_interval = GUARD_INTERVAL_1_8;
979 		break;
980 	case 3:
981 		fe_params->guard_interval = GUARD_INTERVAL_1_4;
982 		break;
983 	}
984 
985 	// hierarchy
986 	switch ((tda1004x_read_byte(state, TDA1004X_OUT_CONF1) & 0x60) >> 5) {
987 	case 0:
988 		fe_params->hierarchy = HIERARCHY_NONE;
989 		break;
990 	case 1:
991 		fe_params->hierarchy = HIERARCHY_1;
992 		break;
993 	case 2:
994 		fe_params->hierarchy = HIERARCHY_2;
995 		break;
996 	case 3:
997 		fe_params->hierarchy = HIERARCHY_4;
998 		break;
999 	}
1000 
1001 	return 0;
1002 }
1003 
1004 static int tda1004x_read_status(struct dvb_frontend *fe,
1005 				enum fe_status *fe_status)
1006 {
1007 	struct tda1004x_state* state = fe->demodulator_priv;
1008 	int status;
1009 	int cber;
1010 	int vber;
1011 
1012 	dprintk("%s\n", __func__);
1013 
1014 	// read status
1015 	status = tda1004x_read_byte(state, TDA1004X_STATUS_CD);
1016 	if (status == -1)
1017 		return -EIO;
1018 
1019 	// decode
1020 	*fe_status = 0;
1021 	if (status & 4)
1022 		*fe_status |= FE_HAS_SIGNAL;
1023 	if (status & 2)
1024 		*fe_status |= FE_HAS_CARRIER;
1025 	if (status & 8)
1026 		*fe_status |= FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
1027 
1028 	// if we don't already have VITERBI (i.e. not LOCKED), see if the viterbi
1029 	// is getting anything valid
1030 	if (!(*fe_status & FE_HAS_VITERBI)) {
1031 		// read the CBER
1032 		cber = tda1004x_read_byte(state, TDA1004X_CBER_LSB);
1033 		if (cber == -1)
1034 			return -EIO;
1035 		status = tda1004x_read_byte(state, TDA1004X_CBER_MSB);
1036 		if (status == -1)
1037 			return -EIO;
1038 		cber |= (status << 8);
1039 		// The address 0x20 should be read to cope with a TDA10046 bug
1040 		tda1004x_read_byte(state, TDA1004X_CBER_RESET);
1041 
1042 		if (cber != 65535)
1043 			*fe_status |= FE_HAS_VITERBI;
1044 	}
1045 
1046 	// if we DO have some valid VITERBI output, but don't already have SYNC
1047 	// bytes (i.e. not LOCKED), see if the RS decoder is getting anything valid.
1048 	if ((*fe_status & FE_HAS_VITERBI) && (!(*fe_status & FE_HAS_SYNC))) {
1049 		// read the VBER
1050 		vber = tda1004x_read_byte(state, TDA1004X_VBER_LSB);
1051 		if (vber == -1)
1052 			return -EIO;
1053 		status = tda1004x_read_byte(state, TDA1004X_VBER_MID);
1054 		if (status == -1)
1055 			return -EIO;
1056 		vber |= (status << 8);
1057 		status = tda1004x_read_byte(state, TDA1004X_VBER_MSB);
1058 		if (status == -1)
1059 			return -EIO;
1060 		vber |= (status & 0x0f) << 16;
1061 		// The CVBER_LUT should be read to cope with TDA10046 hardware bug
1062 		tda1004x_read_byte(state, TDA1004X_CVBER_LUT);
1063 
1064 		// if RS has passed some valid TS packets, then we must be
1065 		// getting some SYNC bytes
1066 		if (vber < 16632)
1067 			*fe_status |= FE_HAS_SYNC;
1068 	}
1069 
1070 	// success
1071 	dprintk("%s: fe_status=0x%x\n", __func__, *fe_status);
1072 	return 0;
1073 }
1074 
1075 static int tda1004x_read_signal_strength(struct dvb_frontend* fe, u16 * signal)
1076 {
1077 	struct tda1004x_state* state = fe->demodulator_priv;
1078 	int tmp;
1079 	int reg = 0;
1080 
1081 	dprintk("%s\n", __func__);
1082 
1083 	// determine the register to use
1084 	switch (state->demod_type) {
1085 	case TDA1004X_DEMOD_TDA10045:
1086 		reg = TDA10045H_S_AGC;
1087 		break;
1088 
1089 	case TDA1004X_DEMOD_TDA10046:
1090 		reg = TDA10046H_AGC_IF_LEVEL;
1091 		break;
1092 	}
1093 
1094 	// read it
1095 	tmp = tda1004x_read_byte(state, reg);
1096 	if (tmp < 0)
1097 		return -EIO;
1098 
1099 	*signal = (tmp << 8) | tmp;
1100 	dprintk("%s: signal=0x%x\n", __func__, *signal);
1101 	return 0;
1102 }
1103 
1104 static int tda1004x_read_snr(struct dvb_frontend* fe, u16 * snr)
1105 {
1106 	struct tda1004x_state* state = fe->demodulator_priv;
1107 	int tmp;
1108 
1109 	dprintk("%s\n", __func__);
1110 
1111 	// read it
1112 	tmp = tda1004x_read_byte(state, TDA1004X_SNR);
1113 	if (tmp < 0)
1114 		return -EIO;
1115 	tmp = 255 - tmp;
1116 
1117 	*snr = ((tmp << 8) | tmp);
1118 	dprintk("%s: snr=0x%x\n", __func__, *snr);
1119 	return 0;
1120 }
1121 
1122 static int tda1004x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
1123 {
1124 	struct tda1004x_state* state = fe->demodulator_priv;
1125 	int tmp;
1126 	int tmp2;
1127 	int counter;
1128 
1129 	dprintk("%s\n", __func__);
1130 
1131 	// read the UCBLOCKS and reset
1132 	counter = 0;
1133 	tmp = tda1004x_read_byte(state, TDA1004X_UNCOR);
1134 	if (tmp < 0)
1135 		return -EIO;
1136 	tmp &= 0x7f;
1137 	while (counter++ < 5) {
1138 		tda1004x_write_mask(state, TDA1004X_UNCOR, 0x80, 0);
1139 		tda1004x_write_mask(state, TDA1004X_UNCOR, 0x80, 0);
1140 		tda1004x_write_mask(state, TDA1004X_UNCOR, 0x80, 0);
1141 
1142 		tmp2 = tda1004x_read_byte(state, TDA1004X_UNCOR);
1143 		if (tmp2 < 0)
1144 			return -EIO;
1145 		tmp2 &= 0x7f;
1146 		if ((tmp2 < tmp) || (tmp2 == 0))
1147 			break;
1148 	}
1149 
1150 	if (tmp != 0x7f)
1151 		*ucblocks = tmp;
1152 	else
1153 		*ucblocks = 0xffffffff;
1154 
1155 	dprintk("%s: ucblocks=0x%x\n", __func__, *ucblocks);
1156 	return 0;
1157 }
1158 
1159 static int tda1004x_read_ber(struct dvb_frontend* fe, u32* ber)
1160 {
1161 	struct tda1004x_state* state = fe->demodulator_priv;
1162 	int tmp;
1163 
1164 	dprintk("%s\n", __func__);
1165 
1166 	// read it in
1167 	tmp = tda1004x_read_byte(state, TDA1004X_CBER_LSB);
1168 	if (tmp < 0)
1169 		return -EIO;
1170 	*ber = tmp << 1;
1171 	tmp = tda1004x_read_byte(state, TDA1004X_CBER_MSB);
1172 	if (tmp < 0)
1173 		return -EIO;
1174 	*ber |= (tmp << 9);
1175 	// The address 0x20 should be read to cope with a TDA10046 bug
1176 	tda1004x_read_byte(state, TDA1004X_CBER_RESET);
1177 
1178 	dprintk("%s: ber=0x%x\n", __func__, *ber);
1179 	return 0;
1180 }
1181 
1182 static int tda1004x_sleep(struct dvb_frontend* fe)
1183 {
1184 	struct tda1004x_state* state = fe->demodulator_priv;
1185 	int gpio_conf;
1186 
1187 	switch (state->demod_type) {
1188 	case TDA1004X_DEMOD_TDA10045:
1189 		tda1004x_write_mask(state, TDA1004X_CONFADC1, 0x10, 0x10);
1190 		break;
1191 
1192 	case TDA1004X_DEMOD_TDA10046:
1193 		/* set outputs to tristate */
1194 		tda1004x_write_byteI(state, TDA10046H_CONF_TRISTATE1, 0xff);
1195 		/* invert GPIO 1 and 3 if desired*/
1196 		gpio_conf = state->config->gpio_config;
1197 		if (gpio_conf >= TDA10046_GP00_I)
1198 			tda1004x_write_mask(state, TDA10046H_CONF_POLARITY, 0x0f,
1199 							(gpio_conf & 0x0f) ^ 0x0a);
1200 
1201 		tda1004x_write_mask(state, TDA1004X_CONFADC2, 0xc0, 0xc0);
1202 		tda1004x_write_mask(state, TDA1004X_CONFC4, 1, 1);
1203 		break;
1204 	}
1205 
1206 	return 0;
1207 }
1208 
1209 static int tda1004x_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
1210 {
1211 	struct tda1004x_state* state = fe->demodulator_priv;
1212 
1213 	if (enable) {
1214 		return tda1004x_enable_tuner_i2c(state);
1215 	} else {
1216 		return tda1004x_disable_tuner_i2c(state);
1217 	}
1218 }
1219 
1220 static int tda1004x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
1221 {
1222 	fesettings->min_delay_ms = 800;
1223 	/* Drift compensation makes no sense for DVB-T */
1224 	fesettings->step_size = 0;
1225 	fesettings->max_drift = 0;
1226 	return 0;
1227 }
1228 
1229 static void tda1004x_release(struct dvb_frontend* fe)
1230 {
1231 	struct tda1004x_state *state = fe->demodulator_priv;
1232 	kfree(state);
1233 }
1234 
1235 static const struct dvb_frontend_ops tda10045_ops = {
1236 	.delsys = { SYS_DVBT },
1237 	.info = {
1238 		.name = "Philips TDA10045H DVB-T",
1239 		.frequency_min_hz =  51 * MHz,
1240 		.frequency_max_hz = 858 * MHz,
1241 		.frequency_stepsize_hz = 166667,
1242 		.caps =
1243 		    FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1244 		    FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1245 		    FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
1246 		    FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO
1247 	},
1248 
1249 	.release = tda1004x_release,
1250 
1251 	.init = tda10045_init,
1252 	.sleep = tda1004x_sleep,
1253 	.write = tda1004x_write,
1254 	.i2c_gate_ctrl = tda1004x_i2c_gate_ctrl,
1255 
1256 	.set_frontend = tda1004x_set_fe,
1257 	.get_frontend = tda1004x_get_fe,
1258 	.get_tune_settings = tda1004x_get_tune_settings,
1259 
1260 	.read_status = tda1004x_read_status,
1261 	.read_ber = tda1004x_read_ber,
1262 	.read_signal_strength = tda1004x_read_signal_strength,
1263 	.read_snr = tda1004x_read_snr,
1264 	.read_ucblocks = tda1004x_read_ucblocks,
1265 };
1266 
1267 struct dvb_frontend* tda10045_attach(const struct tda1004x_config* config,
1268 				     struct i2c_adapter* i2c)
1269 {
1270 	struct tda1004x_state *state;
1271 	int id;
1272 
1273 	/* allocate memory for the internal state */
1274 	state = kzalloc(sizeof(struct tda1004x_state), GFP_KERNEL);
1275 	if (!state) {
1276 		printk(KERN_ERR "Can't allocate memory for tda10045 state\n");
1277 		return NULL;
1278 	}
1279 
1280 	/* setup the state */
1281 	state->config = config;
1282 	state->i2c = i2c;
1283 	state->demod_type = TDA1004X_DEMOD_TDA10045;
1284 
1285 	/* check if the demod is there */
1286 	id = tda1004x_read_byte(state, TDA1004X_CHIPID);
1287 	if (id < 0) {
1288 		printk(KERN_ERR "tda10045: chip is not answering. Giving up.\n");
1289 		kfree(state);
1290 		return NULL;
1291 	}
1292 
1293 	if (id != 0x25) {
1294 		printk(KERN_ERR "Invalid tda1004x ID = 0x%02x. Can't proceed\n", id);
1295 		kfree(state);
1296 		return NULL;
1297 	}
1298 
1299 	/* create dvb_frontend */
1300 	memcpy(&state->frontend.ops, &tda10045_ops, sizeof(struct dvb_frontend_ops));
1301 	state->frontend.demodulator_priv = state;
1302 	return &state->frontend;
1303 }
1304 
1305 static const struct dvb_frontend_ops tda10046_ops = {
1306 	.delsys = { SYS_DVBT },
1307 	.info = {
1308 		.name = "Philips TDA10046H DVB-T",
1309 		.frequency_min_hz =  51 * MHz,
1310 		.frequency_max_hz = 858 * MHz,
1311 		.frequency_stepsize_hz = 166667,
1312 		.caps =
1313 		    FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1314 		    FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1315 		    FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
1316 		    FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO
1317 	},
1318 
1319 	.release = tda1004x_release,
1320 
1321 	.init = tda10046_init,
1322 	.sleep = tda1004x_sleep,
1323 	.write = tda1004x_write,
1324 	.i2c_gate_ctrl = tda1004x_i2c_gate_ctrl,
1325 
1326 	.set_frontend = tda1004x_set_fe,
1327 	.get_frontend = tda1004x_get_fe,
1328 	.get_tune_settings = tda1004x_get_tune_settings,
1329 
1330 	.read_status = tda1004x_read_status,
1331 	.read_ber = tda1004x_read_ber,
1332 	.read_signal_strength = tda1004x_read_signal_strength,
1333 	.read_snr = tda1004x_read_snr,
1334 	.read_ucblocks = tda1004x_read_ucblocks,
1335 };
1336 
1337 struct dvb_frontend* tda10046_attach(const struct tda1004x_config* config,
1338 				     struct i2c_adapter* i2c)
1339 {
1340 	struct tda1004x_state *state;
1341 	int id;
1342 
1343 	/* allocate memory for the internal state */
1344 	state = kzalloc(sizeof(struct tda1004x_state), GFP_KERNEL);
1345 	if (!state) {
1346 		printk(KERN_ERR "Can't allocate memory for tda10046 state\n");
1347 		return NULL;
1348 	}
1349 
1350 	/* setup the state */
1351 	state->config = config;
1352 	state->i2c = i2c;
1353 	state->demod_type = TDA1004X_DEMOD_TDA10046;
1354 
1355 	/* check if the demod is there */
1356 	id = tda1004x_read_byte(state, TDA1004X_CHIPID);
1357 	if (id < 0) {
1358 		printk(KERN_ERR "tda10046: chip is not answering. Giving up.\n");
1359 		kfree(state);
1360 		return NULL;
1361 	}
1362 	if (id != 0x46) {
1363 		printk(KERN_ERR "Invalid tda1004x ID = 0x%02x. Can't proceed\n", id);
1364 		kfree(state);
1365 		return NULL;
1366 	}
1367 
1368 	/* create dvb_frontend */
1369 	memcpy(&state->frontend.ops, &tda10046_ops, sizeof(struct dvb_frontend_ops));
1370 	state->frontend.demodulator_priv = state;
1371 	return &state->frontend;
1372 }
1373 
1374 module_param(debug, int, 0644);
1375 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
1376 
1377 MODULE_DESCRIPTION("Philips TDA10045H & TDA10046H DVB-T Demodulator");
1378 MODULE_AUTHOR("Andrew de Quincey & Robert Schlabbach");
1379 MODULE_LICENSE("GPL");
1380 
1381 EXPORT_SYMBOL_GPL(tda10045_attach);
1382 EXPORT_SYMBOL_GPL(tda10046_attach);
1383