1 /*
2  * Linux-DVB Driver for DiBcom's DiB0090 base-band RF Tuner.
3  *
4  * Copyright (C) 2005-9 DiBcom (http://www.dibcom.fr/)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation; either version 2 of the
9  * License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *
15  * GNU General Public License for more details.
16  *
17  *
18  * This code is more or less generated from another driver, please
19  * excuse some codingstyle oddities.
20  *
21  */
22 
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 
25 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/i2c.h>
28 #include <linux/mutex.h>
29 
30 #include "dvb_frontend.h"
31 
32 #include "dib0090.h"
33 #include "dibx000_common.h"
34 
35 static int debug;
36 module_param(debug, int, 0644);
37 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
38 
39 #define dprintk(fmt, arg...) do {					\
40 	if (debug)							\
41 		printk(KERN_DEBUG pr_fmt("%s: " fmt),			\
42 		       __func__, ##arg);				\
43 } while (0)
44 
45 #define CONFIG_SYS_DVBT
46 #define CONFIG_SYS_ISDBT
47 #define CONFIG_BAND_CBAND
48 #define CONFIG_BAND_VHF
49 #define CONFIG_BAND_UHF
50 #define CONFIG_DIB0090_USE_PWM_AGC
51 
52 #define EN_LNA0      0x8000
53 #define EN_LNA1      0x4000
54 #define EN_LNA2      0x2000
55 #define EN_LNA3      0x1000
56 #define EN_MIX0      0x0800
57 #define EN_MIX1      0x0400
58 #define EN_MIX2      0x0200
59 #define EN_MIX3      0x0100
60 #define EN_IQADC     0x0040
61 #define EN_PLL       0x0020
62 #define EN_TX        0x0010
63 #define EN_BB        0x0008
64 #define EN_LO        0x0004
65 #define EN_BIAS      0x0001
66 
67 #define EN_IQANA     0x0002
68 #define EN_DIGCLK    0x0080	/* not in the 0x24 reg, only in 0x1b */
69 #define EN_CRYSTAL   0x0002
70 
71 #define EN_UHF		 0x22E9
72 #define EN_VHF		 0x44E9
73 #define EN_LBD		 0x11E9
74 #define EN_SBD		 0x44E9
75 #define EN_CAB		 0x88E9
76 
77 /* Calibration defines */
78 #define      DC_CAL 0x1
79 #define     WBD_CAL 0x2
80 #define    TEMP_CAL 0x4
81 #define CAPTRIM_CAL 0x8
82 
83 #define KROSUS_PLL_LOCKED   0x800
84 #define KROSUS              0x2
85 
86 /* Use those defines to identify SOC version */
87 #define SOC               0x02
88 #define SOC_7090_P1G_11R1 0x82
89 #define SOC_7090_P1G_21R1 0x8a
90 #define SOC_8090_P1G_11R1 0x86
91 #define SOC_8090_P1G_21R1 0x8e
92 
93 /* else use thos ones to check */
94 #define P1A_B      0x0
95 #define P1C	   0x1
96 #define P1D_E_F    0x3
97 #define P1G	   0x7
98 #define P1G_21R2   0xf
99 
100 #define MP001 0x1		/* Single 9090/8096 */
101 #define MP005 0x4		/* Single Sband */
102 #define MP008 0x6		/* Dual diversity VHF-UHF-LBAND */
103 #define MP009 0x7		/* Dual diversity 29098 CBAND-UHF-LBAND-SBAND */
104 
105 #define pgm_read_word(w) (*w)
106 
107 struct dc_calibration;
108 
109 struct dib0090_tuning {
110 	u32 max_freq;		/* for every frequency less than or equal to that field: this information is correct */
111 	u8 switch_trim;
112 	u8 lna_tune;
113 	u16 lna_bias;
114 	u16 v2i;
115 	u16 mix;
116 	u16 load;
117 	u16 tuner_enable;
118 };
119 
120 struct dib0090_pll {
121 	u32 max_freq;		/* for every frequency less than or equal to that field: this information is correct */
122 	u8 vco_band;
123 	u8 hfdiv_code;
124 	u8 hfdiv;
125 	u8 topresc;
126 };
127 
128 struct dib0090_identity {
129 	u8 version;
130 	u8 product;
131 	u8 p1g;
132 	u8 in_soc;
133 };
134 
135 struct dib0090_state {
136 	struct i2c_adapter *i2c;
137 	struct dvb_frontend *fe;
138 	const struct dib0090_config *config;
139 
140 	u8 current_band;
141 	enum frontend_tune_state tune_state;
142 	u32 current_rf;
143 
144 	u16 wbd_offset;
145 	s16 wbd_target;		/* in dB */
146 
147 	s16 rf_gain_limit;	/* take-over-point: where to split between bb and rf gain */
148 	s16 current_gain;	/* keeps the currently programmed gain */
149 	u8 agc_step;		/* new binary search */
150 
151 	u16 gain[2];		/* for channel monitoring */
152 
153 	const u16 *rf_ramp;
154 	const u16 *bb_ramp;
155 
156 	/* for the software AGC ramps */
157 	u16 bb_1_def;
158 	u16 rf_lt_def;
159 	u16 gain_reg[4];
160 
161 	/* for the captrim/dc-offset search */
162 	s8 step;
163 	s16 adc_diff;
164 	s16 min_adc_diff;
165 
166 	s8 captrim;
167 	s8 fcaptrim;
168 
169 	const struct dc_calibration *dc;
170 	u16 bb6, bb7;
171 
172 	const struct dib0090_tuning *current_tune_table_index;
173 	const struct dib0090_pll *current_pll_table_index;
174 
175 	u8 tuner_is_tuned;
176 	u8 agc_freeze;
177 
178 	struct dib0090_identity identity;
179 
180 	u32 rf_request;
181 	u8 current_standard;
182 
183 	u8 calibrate;
184 	u32 rest;
185 	u16 bias;
186 	s16 temperature;
187 
188 	u8 wbd_calibration_gain;
189 	const struct dib0090_wbd_slope *current_wbd_table;
190 	u16 wbdmux;
191 
192 	/* for the I2C transfer */
193 	struct i2c_msg msg[2];
194 	u8 i2c_write_buffer[3];
195 	u8 i2c_read_buffer[2];
196 	struct mutex i2c_buffer_lock;
197 };
198 
199 struct dib0090_fw_state {
200 	struct i2c_adapter *i2c;
201 	struct dvb_frontend *fe;
202 	struct dib0090_identity identity;
203 	const struct dib0090_config *config;
204 
205 	/* for the I2C transfer */
206 	struct i2c_msg msg;
207 	u8 i2c_write_buffer[2];
208 	u8 i2c_read_buffer[2];
209 	struct mutex i2c_buffer_lock;
210 };
211 
212 static u16 dib0090_read_reg(struct dib0090_state *state, u8 reg)
213 {
214 	u16 ret;
215 
216 	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
217 		dprintk("could not acquire lock\n");
218 		return 0;
219 	}
220 
221 	state->i2c_write_buffer[0] = reg;
222 
223 	memset(state->msg, 0, 2 * sizeof(struct i2c_msg));
224 	state->msg[0].addr = state->config->i2c_address;
225 	state->msg[0].flags = 0;
226 	state->msg[0].buf = state->i2c_write_buffer;
227 	state->msg[0].len = 1;
228 	state->msg[1].addr = state->config->i2c_address;
229 	state->msg[1].flags = I2C_M_RD;
230 	state->msg[1].buf = state->i2c_read_buffer;
231 	state->msg[1].len = 2;
232 
233 	if (i2c_transfer(state->i2c, state->msg, 2) != 2) {
234 		pr_warn("DiB0090 I2C read failed\n");
235 		ret = 0;
236 	} else
237 		ret = (state->i2c_read_buffer[0] << 8)
238 			| state->i2c_read_buffer[1];
239 
240 	mutex_unlock(&state->i2c_buffer_lock);
241 	return ret;
242 }
243 
244 static int dib0090_write_reg(struct dib0090_state *state, u32 reg, u16 val)
245 {
246 	int ret;
247 
248 	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
249 		dprintk("could not acquire lock\n");
250 		return -EINVAL;
251 	}
252 
253 	state->i2c_write_buffer[0] = reg & 0xff;
254 	state->i2c_write_buffer[1] = val >> 8;
255 	state->i2c_write_buffer[2] = val & 0xff;
256 
257 	memset(state->msg, 0, sizeof(struct i2c_msg));
258 	state->msg[0].addr = state->config->i2c_address;
259 	state->msg[0].flags = 0;
260 	state->msg[0].buf = state->i2c_write_buffer;
261 	state->msg[0].len = 3;
262 
263 	if (i2c_transfer(state->i2c, state->msg, 1) != 1) {
264 		pr_warn("DiB0090 I2C write failed\n");
265 		ret = -EREMOTEIO;
266 	} else
267 		ret = 0;
268 
269 	mutex_unlock(&state->i2c_buffer_lock);
270 	return ret;
271 }
272 
273 static u16 dib0090_fw_read_reg(struct dib0090_fw_state *state, u8 reg)
274 {
275 	u16 ret;
276 
277 	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
278 		dprintk("could not acquire lock\n");
279 		return 0;
280 	}
281 
282 	state->i2c_write_buffer[0] = reg;
283 
284 	memset(&state->msg, 0, sizeof(struct i2c_msg));
285 	state->msg.addr = reg;
286 	state->msg.flags = I2C_M_RD;
287 	state->msg.buf = state->i2c_read_buffer;
288 	state->msg.len = 2;
289 	if (i2c_transfer(state->i2c, &state->msg, 1) != 1) {
290 		pr_warn("DiB0090 I2C read failed\n");
291 		ret = 0;
292 	} else
293 		ret = (state->i2c_read_buffer[0] << 8)
294 			| state->i2c_read_buffer[1];
295 
296 	mutex_unlock(&state->i2c_buffer_lock);
297 	return ret;
298 }
299 
300 static int dib0090_fw_write_reg(struct dib0090_fw_state *state, u8 reg, u16 val)
301 {
302 	int ret;
303 
304 	if (mutex_lock_interruptible(&state->i2c_buffer_lock) < 0) {
305 		dprintk("could not acquire lock\n");
306 		return -EINVAL;
307 	}
308 
309 	state->i2c_write_buffer[0] = val >> 8;
310 	state->i2c_write_buffer[1] = val & 0xff;
311 
312 	memset(&state->msg, 0, sizeof(struct i2c_msg));
313 	state->msg.addr = reg;
314 	state->msg.flags = 0;
315 	state->msg.buf = state->i2c_write_buffer;
316 	state->msg.len = 2;
317 	if (i2c_transfer(state->i2c, &state->msg, 1) != 1) {
318 		pr_warn("DiB0090 I2C write failed\n");
319 		ret = -EREMOTEIO;
320 	} else
321 		ret = 0;
322 
323 	mutex_unlock(&state->i2c_buffer_lock);
324 	return ret;
325 }
326 
327 #define HARD_RESET(state) do {  if (cfg->reset) {  if (cfg->sleep) cfg->sleep(fe, 0); msleep(10);  cfg->reset(fe, 1); msleep(10);  cfg->reset(fe, 0); msleep(10);  }  } while (0)
328 #define ADC_TARGET -220
329 #define GAIN_ALPHA 5
330 #define WBD_ALPHA 6
331 #define LPF	100
332 static void dib0090_write_regs(struct dib0090_state *state, u8 r, const u16 * b, u8 c)
333 {
334 	do {
335 		dib0090_write_reg(state, r++, *b++);
336 	} while (--c);
337 }
338 
339 static int dib0090_identify(struct dvb_frontend *fe)
340 {
341 	struct dib0090_state *state = fe->tuner_priv;
342 	u16 v;
343 	struct dib0090_identity *identity = &state->identity;
344 
345 	v = dib0090_read_reg(state, 0x1a);
346 
347 	identity->p1g = 0;
348 	identity->in_soc = 0;
349 
350 	dprintk("Tuner identification (Version = 0x%04x)\n", v);
351 
352 	/* without PLL lock info */
353 	v &= ~KROSUS_PLL_LOCKED;
354 
355 	identity->version = v & 0xff;
356 	identity->product = (v >> 8) & 0xf;
357 
358 	if (identity->product != KROSUS)
359 		goto identification_error;
360 
361 	if ((identity->version & 0x3) == SOC) {
362 		identity->in_soc = 1;
363 		switch (identity->version) {
364 		case SOC_8090_P1G_11R1:
365 			dprintk("SOC 8090 P1-G11R1 Has been detected\n");
366 			identity->p1g = 1;
367 			break;
368 		case SOC_8090_P1G_21R1:
369 			dprintk("SOC 8090 P1-G21R1 Has been detected\n");
370 			identity->p1g = 1;
371 			break;
372 		case SOC_7090_P1G_11R1:
373 			dprintk("SOC 7090 P1-G11R1 Has been detected\n");
374 			identity->p1g = 1;
375 			break;
376 		case SOC_7090_P1G_21R1:
377 			dprintk("SOC 7090 P1-G21R1 Has been detected\n");
378 			identity->p1g = 1;
379 			break;
380 		default:
381 			goto identification_error;
382 		}
383 	} else {
384 		switch ((identity->version >> 5) & 0x7) {
385 		case MP001:
386 			dprintk("MP001 : 9090/8096\n");
387 			break;
388 		case MP005:
389 			dprintk("MP005 : Single Sband\n");
390 			break;
391 		case MP008:
392 			dprintk("MP008 : diversity VHF-UHF-LBAND\n");
393 			break;
394 		case MP009:
395 			dprintk("MP009 : diversity 29098 CBAND-UHF-LBAND-SBAND\n");
396 			break;
397 		default:
398 			goto identification_error;
399 		}
400 
401 		switch (identity->version & 0x1f) {
402 		case P1G_21R2:
403 			dprintk("P1G_21R2 detected\n");
404 			identity->p1g = 1;
405 			break;
406 		case P1G:
407 			dprintk("P1G detected\n");
408 			identity->p1g = 1;
409 			break;
410 		case P1D_E_F:
411 			dprintk("P1D/E/F detected\n");
412 			break;
413 		case P1C:
414 			dprintk("P1C detected\n");
415 			break;
416 		case P1A_B:
417 			dprintk("P1-A/B detected: driver is deactivated - not available\n");
418 			goto identification_error;
419 			break;
420 		default:
421 			goto identification_error;
422 		}
423 	}
424 
425 	return 0;
426 
427 identification_error:
428 	return -EIO;
429 }
430 
431 static int dib0090_fw_identify(struct dvb_frontend *fe)
432 {
433 	struct dib0090_fw_state *state = fe->tuner_priv;
434 	struct dib0090_identity *identity = &state->identity;
435 
436 	u16 v = dib0090_fw_read_reg(state, 0x1a);
437 	identity->p1g = 0;
438 	identity->in_soc = 0;
439 
440 	dprintk("FE: Tuner identification (Version = 0x%04x)\n", v);
441 
442 	/* without PLL lock info */
443 	v &= ~KROSUS_PLL_LOCKED;
444 
445 	identity->version = v & 0xff;
446 	identity->product = (v >> 8) & 0xf;
447 
448 	if (identity->product != KROSUS)
449 		goto identification_error;
450 
451 	if ((identity->version & 0x3) == SOC) {
452 		identity->in_soc = 1;
453 		switch (identity->version) {
454 		case SOC_8090_P1G_11R1:
455 			dprintk("SOC 8090 P1-G11R1 Has been detected\n");
456 			identity->p1g = 1;
457 			break;
458 		case SOC_8090_P1G_21R1:
459 			dprintk("SOC 8090 P1-G21R1 Has been detected\n");
460 			identity->p1g = 1;
461 			break;
462 		case SOC_7090_P1G_11R1:
463 			dprintk("SOC 7090 P1-G11R1 Has been detected\n");
464 			identity->p1g = 1;
465 			break;
466 		case SOC_7090_P1G_21R1:
467 			dprintk("SOC 7090 P1-G21R1 Has been detected\n");
468 			identity->p1g = 1;
469 			break;
470 		default:
471 			goto identification_error;
472 		}
473 	} else {
474 		switch ((identity->version >> 5) & 0x7) {
475 		case MP001:
476 			dprintk("MP001 : 9090/8096\n");
477 			break;
478 		case MP005:
479 			dprintk("MP005 : Single Sband\n");
480 			break;
481 		case MP008:
482 			dprintk("MP008 : diversity VHF-UHF-LBAND\n");
483 			break;
484 		case MP009:
485 			dprintk("MP009 : diversity 29098 CBAND-UHF-LBAND-SBAND\n");
486 			break;
487 		default:
488 			goto identification_error;
489 		}
490 
491 		switch (identity->version & 0x1f) {
492 		case P1G_21R2:
493 			dprintk("P1G_21R2 detected\n");
494 			identity->p1g = 1;
495 			break;
496 		case P1G:
497 			dprintk("P1G detected\n");
498 			identity->p1g = 1;
499 			break;
500 		case P1D_E_F:
501 			dprintk("P1D/E/F detected\n");
502 			break;
503 		case P1C:
504 			dprintk("P1C detected\n");
505 			break;
506 		case P1A_B:
507 			dprintk("P1-A/B detected: driver is deactivated - not available\n");
508 			goto identification_error;
509 			break;
510 		default:
511 			goto identification_error;
512 		}
513 	}
514 
515 	return 0;
516 
517 identification_error:
518 	return -EIO;
519 }
520 
521 static void dib0090_reset_digital(struct dvb_frontend *fe, const struct dib0090_config *cfg)
522 {
523 	struct dib0090_state *state = fe->tuner_priv;
524 	u16 PllCfg, i, v;
525 
526 	HARD_RESET(state);
527 	dib0090_write_reg(state, 0x24, EN_PLL | EN_CRYSTAL);
528 	if (cfg->in_soc)
529 		return;
530 
531 	dib0090_write_reg(state, 0x1b, EN_DIGCLK | EN_PLL | EN_CRYSTAL);	/* PLL, DIG_CLK and CRYSTAL remain */
532 	/* adcClkOutRatio=8->7, release reset */
533 	dib0090_write_reg(state, 0x20, ((cfg->io.adc_clock_ratio - 1) << 11) | (0 << 10) | (1 << 9) | (1 << 8) | (0 << 4) | 0);
534 	if (cfg->clkoutdrive != 0)
535 		dib0090_write_reg(state, 0x23, (0 << 15) | ((!cfg->analog_output) << 14) | (2 << 10) | (1 << 9) | (0 << 8)
536 				| (cfg->clkoutdrive << 5) | (cfg->clkouttobamse << 4) | (0 << 2) | (0));
537 	else
538 		dib0090_write_reg(state, 0x23, (0 << 15) | ((!cfg->analog_output) << 14) | (2 << 10) | (1 << 9) | (0 << 8)
539 				| (7 << 5) | (cfg->clkouttobamse << 4) | (0 << 2) | (0));
540 
541 	/* Read Pll current config * */
542 	PllCfg = dib0090_read_reg(state, 0x21);
543 
544 	/** Reconfigure PLL if current setting is different from default setting **/
545 	if ((PllCfg & 0x1FFF) != ((cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv)) && (!cfg->in_soc)
546 			&& !cfg->io.pll_bypass) {
547 
548 		/* Set Bypass mode */
549 		PllCfg |= (1 << 15);
550 		dib0090_write_reg(state, 0x21, PllCfg);
551 
552 		/* Set Reset Pll */
553 		PllCfg &= ~(1 << 13);
554 		dib0090_write_reg(state, 0x21, PllCfg);
555 
556 	/*** Set new Pll configuration in bypass and reset state ***/
557 		PllCfg = (1 << 15) | (0 << 13) | (cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv);
558 		dib0090_write_reg(state, 0x21, PllCfg);
559 
560 		/* Remove Reset Pll */
561 		PllCfg |= (1 << 13);
562 		dib0090_write_reg(state, 0x21, PllCfg);
563 
564 	/*** Wait for PLL lock ***/
565 		i = 100;
566 		do {
567 			v = !!(dib0090_read_reg(state, 0x1a) & 0x800);
568 			if (v)
569 				break;
570 		} while (--i);
571 
572 		if (i == 0) {
573 			dprintk("Pll: Unable to lock Pll\n");
574 			return;
575 		}
576 
577 		/* Finally Remove Bypass mode */
578 		PllCfg &= ~(1 << 15);
579 		dib0090_write_reg(state, 0x21, PllCfg);
580 	}
581 
582 	if (cfg->io.pll_bypass) {
583 		PllCfg |= (cfg->io.pll_bypass << 15);
584 		dib0090_write_reg(state, 0x21, PllCfg);
585 	}
586 }
587 
588 static int dib0090_fw_reset_digital(struct dvb_frontend *fe, const struct dib0090_config *cfg)
589 {
590 	struct dib0090_fw_state *state = fe->tuner_priv;
591 	u16 PllCfg;
592 	u16 v;
593 	int i;
594 
595 	dprintk("fw reset digital\n");
596 	HARD_RESET(state);
597 
598 	dib0090_fw_write_reg(state, 0x24, EN_PLL | EN_CRYSTAL);
599 	dib0090_fw_write_reg(state, 0x1b, EN_DIGCLK | EN_PLL | EN_CRYSTAL);	/* PLL, DIG_CLK and CRYSTAL remain */
600 
601 	dib0090_fw_write_reg(state, 0x20,
602 			((cfg->io.adc_clock_ratio - 1) << 11) | (0 << 10) | (1 << 9) | (1 << 8) | (cfg->data_tx_drv << 4) | cfg->ls_cfg_pad_drv);
603 
604 	v = (0 << 15) | ((!cfg->analog_output) << 14) | (1 << 9) | (0 << 8) | (cfg->clkouttobamse << 4) | (0 << 2) | (0);
605 	if (cfg->clkoutdrive != 0)
606 		v |= cfg->clkoutdrive << 5;
607 	else
608 		v |= 7 << 5;
609 
610 	v |= 2 << 10;
611 	dib0090_fw_write_reg(state, 0x23, v);
612 
613 	/* Read Pll current config * */
614 	PllCfg = dib0090_fw_read_reg(state, 0x21);
615 
616 	/** Reconfigure PLL if current setting is different from default setting **/
617 	if ((PllCfg & 0x1FFF) != ((cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv)) && !cfg->io.pll_bypass) {
618 
619 		/* Set Bypass mode */
620 		PllCfg |= (1 << 15);
621 		dib0090_fw_write_reg(state, 0x21, PllCfg);
622 
623 		/* Set Reset Pll */
624 		PllCfg &= ~(1 << 13);
625 		dib0090_fw_write_reg(state, 0x21, PllCfg);
626 
627 	/*** Set new Pll configuration in bypass and reset state ***/
628 		PllCfg = (1 << 15) | (0 << 13) | (cfg->io.pll_range << 12) | (cfg->io.pll_loopdiv << 6) | (cfg->io.pll_prediv);
629 		dib0090_fw_write_reg(state, 0x21, PllCfg);
630 
631 		/* Remove Reset Pll */
632 		PllCfg |= (1 << 13);
633 		dib0090_fw_write_reg(state, 0x21, PllCfg);
634 
635 	/*** Wait for PLL lock ***/
636 		i = 100;
637 		do {
638 			v = !!(dib0090_fw_read_reg(state, 0x1a) & 0x800);
639 			if (v)
640 				break;
641 		} while (--i);
642 
643 		if (i == 0) {
644 			dprintk("Pll: Unable to lock Pll\n");
645 			return -EIO;
646 		}
647 
648 		/* Finally Remove Bypass mode */
649 		PllCfg &= ~(1 << 15);
650 		dib0090_fw_write_reg(state, 0x21, PllCfg);
651 	}
652 
653 	if (cfg->io.pll_bypass) {
654 		PllCfg |= (cfg->io.pll_bypass << 15);
655 		dib0090_fw_write_reg(state, 0x21, PllCfg);
656 	}
657 
658 	return dib0090_fw_identify(fe);
659 }
660 
661 static int dib0090_wakeup(struct dvb_frontend *fe)
662 {
663 	struct dib0090_state *state = fe->tuner_priv;
664 	if (state->config->sleep)
665 		state->config->sleep(fe, 0);
666 
667 	/* enable dataTX in case we have been restarted in the wrong moment */
668 	dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14));
669 	return 0;
670 }
671 
672 static int dib0090_sleep(struct dvb_frontend *fe)
673 {
674 	struct dib0090_state *state = fe->tuner_priv;
675 	if (state->config->sleep)
676 		state->config->sleep(fe, 1);
677 	return 0;
678 }
679 
680 void dib0090_dcc_freq(struct dvb_frontend *fe, u8 fast)
681 {
682 	struct dib0090_state *state = fe->tuner_priv;
683 	if (fast)
684 		dib0090_write_reg(state, 0x04, 0);
685 	else
686 		dib0090_write_reg(state, 0x04, 1);
687 }
688 
689 EXPORT_SYMBOL(dib0090_dcc_freq);
690 
691 static const u16 bb_ramp_pwm_normal_socs[] = {
692 	550, /* max BB gain in 10th of dB */
693 	(1<<9) | 8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */
694 	440,
695 	(4  << 9) | 0, /* BB_RAMP3 = 26dB */
696 	(0  << 9) | 208, /* BB_RAMP4 */
697 	(4  << 9) | 208, /* BB_RAMP5 = 29dB */
698 	(0  << 9) | 440, /* BB_RAMP6 */
699 };
700 
701 static const u16 rf_ramp_pwm_cband_7090p[] = {
702 	280, /* max RF gain in 10th of dB */
703 	18, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
704 	504, /* ramp_max = maximum X used on the ramp */
705 	(29 << 10) | 364, /* RF_RAMP5, LNA 1 = 8dB */
706 	(0  << 10) | 504, /* RF_RAMP6, LNA 1 */
707 	(60 << 10) | 228, /* RF_RAMP7, LNA 2 = 7.7dB */
708 	(0  << 10) | 364, /* RF_RAMP8, LNA 2 */
709 	(34 << 10) | 109, /* GAIN_4_1, LNA 3 = 6.8dB */
710 	(0  << 10) | 228, /* GAIN_4_2, LNA 3 */
711 	(37 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */
712 	(0  << 10) | 109, /* RF_RAMP4, LNA 4 */
713 };
714 
715 static const u16 rf_ramp_pwm_cband_7090e_sensitivity[] = {
716 	186, /* max RF gain in 10th of dB */
717 	40, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
718 	746, /* ramp_max = maximum X used on the ramp */
719 	(10 << 10) | 345, /* RF_RAMP5, LNA 1 = 10dB */
720 	(0  << 10) | 746, /* RF_RAMP6, LNA 1 */
721 	(0 << 10) | 0, /* RF_RAMP7, LNA 2 = 0 dB */
722 	(0  << 10) | 0, /* RF_RAMP8, LNA 2 */
723 	(28 << 10) | 200, /* GAIN_4_1, LNA 3 = 6.8dB */ /* 3.61 dB */
724 	(0  << 10) | 345, /* GAIN_4_2, LNA 3 */
725 	(20 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ /* 4.96 dB */
726 	(0  << 10) | 200, /* RF_RAMP4, LNA 4 */
727 };
728 
729 static const u16 rf_ramp_pwm_cband_7090e_aci[] = {
730 	86, /* max RF gain in 10th of dB */
731 	40, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
732 	345, /* ramp_max = maximum X used on the ramp */
733 	(0 << 10) | 0, /* RF_RAMP5, LNA 1 = 8dB */ /* 7.47 dB */
734 	(0 << 10) | 0, /* RF_RAMP6, LNA 1 */
735 	(0 << 10) | 0, /* RF_RAMP7, LNA 2 = 0 dB */
736 	(0 << 10) | 0, /* RF_RAMP8, LNA 2 */
737 	(28 << 10) | 200, /* GAIN_4_1, LNA 3 = 6.8dB */ /* 3.61 dB */
738 	(0  << 10) | 345, /* GAIN_4_2, LNA 3 */
739 	(20 << 10) | 0, /* RF_RAMP3, LNA 4 = 6.2dB */ /* 4.96 dB */
740 	(0  << 10) | 200, /* RF_RAMP4, LNA 4 */
741 };
742 
743 static const u16 rf_ramp_pwm_cband_8090[] = {
744 	345, /* max RF gain in 10th of dB */
745 	29, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
746 	1000, /* ramp_max = maximum X used on the ramp */
747 	(35 << 10) | 772, /* RF_RAMP3, LNA 1 = 8dB */
748 	(0  << 10) | 1000, /* RF_RAMP4, LNA 1 */
749 	(58 << 10) | 496, /* RF_RAMP5, LNA 2 = 9.5dB */
750 	(0  << 10) | 772, /* RF_RAMP6, LNA 2 */
751 	(27 << 10) | 200, /* RF_RAMP7, LNA 3 = 10.5dB */
752 	(0  << 10) | 496, /* RF_RAMP8, LNA 3 */
753 	(40 << 10) | 0, /* GAIN_4_1, LNA 4 = 7dB */
754 	(0  << 10) | 200, /* GAIN_4_2, LNA 4 */
755 };
756 
757 static const u16 rf_ramp_pwm_uhf_7090[] = {
758 	407, /* max RF gain in 10th of dB */
759 	13, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
760 	529, /* ramp_max = maximum X used on the ramp */
761 	(23 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.7dB */
762 	(0  << 10) | 176, /* RF_RAMP4, LNA 1 */
763 	(63 << 10) | 400, /* RF_RAMP5, LNA 2 = 8dB */
764 	(0  << 10) | 529, /* RF_RAMP6, LNA 2 */
765 	(48 << 10) | 316, /* RF_RAMP7, LNA 3 = 6.8dB */
766 	(0  << 10) | 400, /* RF_RAMP8, LNA 3 */
767 	(29 << 10) | 176, /* GAIN_4_1, LNA 4 = 11.5dB */
768 	(0  << 10) | 316, /* GAIN_4_2, LNA 4 */
769 };
770 
771 static const u16 rf_ramp_pwm_uhf_8090[] = {
772 	388, /* max RF gain in 10th of dB */
773 	26, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
774 	1008, /* ramp_max = maximum X used on the ramp */
775 	(11 << 10) | 0, /* RF_RAMP3, LNA 1 = 14.7dB */
776 	(0  << 10) | 369, /* RF_RAMP4, LNA 1 */
777 	(41 << 10) | 809, /* RF_RAMP5, LNA 2 = 8dB */
778 	(0  << 10) | 1008, /* RF_RAMP6, LNA 2 */
779 	(27 << 10) | 659, /* RF_RAMP7, LNA 3 = 6dB */
780 	(0  << 10) | 809, /* RF_RAMP8, LNA 3 */
781 	(14 << 10) | 369, /* GAIN_4_1, LNA 4 = 11.5dB */
782 	(0  << 10) | 659, /* GAIN_4_2, LNA 4 */
783 };
784 
785 /* GENERAL PWM ramp definition for all other Krosus */
786 static const u16 bb_ramp_pwm_normal[] = {
787 	500, /* max BB gain in 10th of dB */
788 	8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */
789 	400,
790 	(2  << 9) | 0, /* BB_RAMP3 = 21dB */
791 	(0  << 9) | 168, /* BB_RAMP4 */
792 	(2  << 9) | 168, /* BB_RAMP5 = 29dB */
793 	(0  << 9) | 400, /* BB_RAMP6 */
794 };
795 
796 #if 0
797 /* Currently unused */
798 static const u16 bb_ramp_pwm_boost[] = {
799 	550, /* max BB gain in 10th of dB */
800 	8, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> BB_RAMP2 */
801 	440,
802 	(2  << 9) | 0, /* BB_RAMP3 = 26dB */
803 	(0  << 9) | 208, /* BB_RAMP4 */
804 	(2  << 9) | 208, /* BB_RAMP5 = 29dB */
805 	(0  << 9) | 440, /* BB_RAMP6 */
806 };
807 #endif
808 
809 static const u16 rf_ramp_pwm_cband[] = {
810 	314, /* max RF gain in 10th of dB */
811 	33, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
812 	1023, /* ramp_max = maximum X used on the ramp */
813 	(8  << 10) | 743, /* RF_RAMP3, LNA 1 = 0dB */
814 	(0  << 10) | 1023, /* RF_RAMP4, LNA 1 */
815 	(15 << 10) | 469, /* RF_RAMP5, LNA 2 = 0dB */
816 	(0  << 10) | 742, /* RF_RAMP6, LNA 2 */
817 	(9  << 10) | 234, /* RF_RAMP7, LNA 3 = 0dB */
818 	(0  << 10) | 468, /* RF_RAMP8, LNA 3 */
819 	(9  << 10) | 0, /* GAIN_4_1, LNA 4 = 0dB */
820 	(0  << 10) | 233, /* GAIN_4_2, LNA 4 */
821 };
822 
823 static const u16 rf_ramp_pwm_vhf[] = {
824 	398, /* max RF gain in 10th of dB */
825 	24, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
826 	954, /* ramp_max = maximum X used on the ramp */
827 	(7  << 10) | 0, /* RF_RAMP3, LNA 1 = 13.2dB */
828 	(0  << 10) | 290, /* RF_RAMP4, LNA 1 */
829 	(16 << 10) | 699, /* RF_RAMP5, LNA 2 = 10.5dB */
830 	(0  << 10) | 954, /* RF_RAMP6, LNA 2 */
831 	(17 << 10) | 580, /* RF_RAMP7, LNA 3 = 5dB */
832 	(0  << 10) | 699, /* RF_RAMP8, LNA 3 */
833 	(7  << 10) | 290, /* GAIN_4_1, LNA 4 = 12.5dB */
834 	(0  << 10) | 580, /* GAIN_4_2, LNA 4 */
835 };
836 
837 static const u16 rf_ramp_pwm_uhf[] = {
838 	398, /* max RF gain in 10th of dB */
839 	24, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
840 	954, /* ramp_max = maximum X used on the ramp */
841 	(7  << 10) | 0, /* RF_RAMP3, LNA 1 = 13.2dB */
842 	(0  << 10) | 290, /* RF_RAMP4, LNA 1 */
843 	(16 << 10) | 699, /* RF_RAMP5, LNA 2 = 10.5dB */
844 	(0  << 10) | 954, /* RF_RAMP6, LNA 2 */
845 	(17 << 10) | 580, /* RF_RAMP7, LNA 3 = 5dB */
846 	(0  << 10) | 699, /* RF_RAMP8, LNA 3 */
847 	(7  << 10) | 290, /* GAIN_4_1, LNA 4 = 12.5dB */
848 	(0  << 10) | 580, /* GAIN_4_2, LNA 4 */
849 };
850 
851 #if 0
852 /* Currently unused */
853 static const u16 rf_ramp_pwm_sband[] = {
854 	253, /* max RF gain in 10th of dB */
855 	38, /* ramp_slope = 1dB of gain -> clock_ticks_per_db = clk_khz / ramp_slope -> RF_RAMP2 */
856 	961,
857 	(4  << 10) | 0, /* RF_RAMP3, LNA 1 = 14.1dB */
858 	(0  << 10) | 508, /* RF_RAMP4, LNA 1 */
859 	(9  << 10) | 508, /* RF_RAMP5, LNA 2 = 11.2dB */
860 	(0  << 10) | 961, /* RF_RAMP6, LNA 2 */
861 	(0  << 10) | 0, /* RF_RAMP7, LNA 3 = 0dB */
862 	(0  << 10) | 0, /* RF_RAMP8, LNA 3 */
863 	(0  << 10) | 0, /* GAIN_4_1, LNA 4 = 0dB */
864 	(0  << 10) | 0, /* GAIN_4_2, LNA 4 */
865 };
866 #endif
867 
868 struct slope {
869 	s16 range;
870 	s16 slope;
871 };
872 static u16 slopes_to_scale(const struct slope *slopes, u8 num, s16 val)
873 {
874 	u8 i;
875 	u16 rest;
876 	u16 ret = 0;
877 	for (i = 0; i < num; i++) {
878 		if (val > slopes[i].range)
879 			rest = slopes[i].range;
880 		else
881 			rest = val;
882 		ret += (rest * slopes[i].slope) / slopes[i].range;
883 		val -= rest;
884 	}
885 	return ret;
886 }
887 
888 static const struct slope dib0090_wbd_slopes[3] = {
889 	{66, 120},		/* -64,-52: offset -   65 */
890 	{600, 170},		/* -52,-35: 65     -  665 */
891 	{170, 250},		/* -45,-10: 665    - 835 */
892 };
893 
894 static s16 dib0090_wbd_to_db(struct dib0090_state *state, u16 wbd)
895 {
896 	wbd &= 0x3ff;
897 	if (wbd < state->wbd_offset)
898 		wbd = 0;
899 	else
900 		wbd -= state->wbd_offset;
901 	/* -64dB is the floor */
902 	return -640 + (s16) slopes_to_scale(dib0090_wbd_slopes, ARRAY_SIZE(dib0090_wbd_slopes), wbd);
903 }
904 
905 static void dib0090_wbd_target(struct dib0090_state *state, u32 rf)
906 {
907 	u16 offset = 250;
908 
909 	/* TODO : DAB digital N+/-1 interferer perfs : offset = 10 */
910 
911 	if (state->current_band == BAND_VHF)
912 		offset = 650;
913 #ifndef FIRMWARE_FIREFLY
914 	if (state->current_band == BAND_VHF)
915 		offset = state->config->wbd_vhf_offset;
916 	if (state->current_band == BAND_CBAND)
917 		offset = state->config->wbd_cband_offset;
918 #endif
919 
920 	state->wbd_target = dib0090_wbd_to_db(state, state->wbd_offset + offset);
921 	dprintk("wbd-target: %d dB\n", (u32) state->wbd_target);
922 }
923 
924 static const int gain_reg_addr[4] = {
925 	0x08, 0x0a, 0x0f, 0x01
926 };
927 
928 static void dib0090_gain_apply(struct dib0090_state *state, s16 gain_delta, s16 top_delta, u8 force)
929 {
930 	u16 rf, bb, ref;
931 	u16 i, v, gain_reg[4] = { 0 }, gain;
932 	const u16 *g;
933 
934 	if (top_delta < -511)
935 		top_delta = -511;
936 	if (top_delta > 511)
937 		top_delta = 511;
938 
939 	if (force) {
940 		top_delta *= (1 << WBD_ALPHA);
941 		gain_delta *= (1 << GAIN_ALPHA);
942 	}
943 
944 	if (top_delta >= ((s16) (state->rf_ramp[0] << WBD_ALPHA) - state->rf_gain_limit))	/* overflow */
945 		state->rf_gain_limit = state->rf_ramp[0] << WBD_ALPHA;
946 	else
947 		state->rf_gain_limit += top_delta;
948 
949 	if (state->rf_gain_limit < 0)	/*underflow */
950 		state->rf_gain_limit = 0;
951 
952 	/* use gain as a temporary variable and correct current_gain */
953 	gain = ((state->rf_gain_limit >> WBD_ALPHA) + state->bb_ramp[0]) << GAIN_ALPHA;
954 	if (gain_delta >= ((s16) gain - state->current_gain))	/* overflow */
955 		state->current_gain = gain;
956 	else
957 		state->current_gain += gain_delta;
958 	/* cannot be less than 0 (only if gain_delta is less than 0 we can have current_gain < 0) */
959 	if (state->current_gain < 0)
960 		state->current_gain = 0;
961 
962 	/* now split total gain to rf and bb gain */
963 	gain = state->current_gain >> GAIN_ALPHA;
964 
965 	/* requested gain is bigger than rf gain limit - ACI/WBD adjustment */
966 	if (gain > (state->rf_gain_limit >> WBD_ALPHA)) {
967 		rf = state->rf_gain_limit >> WBD_ALPHA;
968 		bb = gain - rf;
969 		if (bb > state->bb_ramp[0])
970 			bb = state->bb_ramp[0];
971 	} else {		/* high signal level -> all gains put on RF */
972 		rf = gain;
973 		bb = 0;
974 	}
975 
976 	state->gain[0] = rf;
977 	state->gain[1] = bb;
978 
979 	/* software ramp */
980 	/* Start with RF gains */
981 	g = state->rf_ramp + 1;	/* point on RF LNA1 max gain */
982 	ref = rf;
983 	for (i = 0; i < 7; i++) {	/* Go over all amplifiers => 5RF amps + 2 BB amps = 7 amps */
984 		if (g[0] == 0 || ref < (g[1] - g[0]))	/* if total gain of the current amp is null or this amp is not concerned because it starts to work from an higher gain value */
985 			v = 0;	/* force the gain to write for the current amp to be null */
986 		else if (ref >= g[1])	/* Gain to set is higher than the high working point of this amp */
987 			v = g[2];	/* force this amp to be full gain */
988 		else		/* compute the value to set to this amp because we are somewhere in his range */
989 			v = ((ref - (g[1] - g[0])) * g[2]) / g[0];
990 
991 		if (i == 0)	/* LNA 1 reg mapping */
992 			gain_reg[0] = v;
993 		else if (i == 1)	/* LNA 2 reg mapping */
994 			gain_reg[0] |= v << 7;
995 		else if (i == 2)	/* LNA 3 reg mapping */
996 			gain_reg[1] = v;
997 		else if (i == 3)	/* LNA 4 reg mapping */
998 			gain_reg[1] |= v << 7;
999 		else if (i == 4)	/* CBAND LNA reg mapping */
1000 			gain_reg[2] = v | state->rf_lt_def;
1001 		else if (i == 5)	/* BB gain 1 reg mapping */
1002 			gain_reg[3] = v << 3;
1003 		else if (i == 6)	/* BB gain 2 reg mapping */
1004 			gain_reg[3] |= v << 8;
1005 
1006 		g += 3;		/* go to next gain bloc */
1007 
1008 		/* When RF is finished, start with BB */
1009 		if (i == 4) {
1010 			g = state->bb_ramp + 1;	/* point on BB gain 1 max gain */
1011 			ref = bb;
1012 		}
1013 	}
1014 	gain_reg[3] |= state->bb_1_def;
1015 	gain_reg[3] |= ((bb % 10) * 100) / 125;
1016 
1017 #ifdef DEBUG_AGC
1018 	dprintk("GA CALC: DB: %3d(rf) + %3d(bb) = %3d gain_reg[0]=%04x gain_reg[1]=%04x gain_reg[2]=%04x gain_reg[0]=%04x\n", rf, bb, rf + bb,
1019 		gain_reg[0], gain_reg[1], gain_reg[2], gain_reg[3]);
1020 #endif
1021 
1022 	/* Write the amplifier regs */
1023 	for (i = 0; i < 4; i++) {
1024 		v = gain_reg[i];
1025 		if (force || state->gain_reg[i] != v) {
1026 			state->gain_reg[i] = v;
1027 			dib0090_write_reg(state, gain_reg_addr[i], v);
1028 		}
1029 	}
1030 }
1031 
1032 static void dib0090_set_boost(struct dib0090_state *state, int onoff)
1033 {
1034 	state->bb_1_def &= 0xdfff;
1035 	state->bb_1_def |= onoff << 13;
1036 }
1037 
1038 static void dib0090_set_rframp(struct dib0090_state *state, const u16 * cfg)
1039 {
1040 	state->rf_ramp = cfg;
1041 }
1042 
1043 static void dib0090_set_rframp_pwm(struct dib0090_state *state, const u16 * cfg)
1044 {
1045 	state->rf_ramp = cfg;
1046 
1047 	dib0090_write_reg(state, 0x2a, 0xffff);
1048 
1049 	dprintk("total RF gain: %ddB, step: %d\n", (u32) cfg[0], dib0090_read_reg(state, 0x2a));
1050 
1051 	dib0090_write_regs(state, 0x2c, cfg + 3, 6);
1052 	dib0090_write_regs(state, 0x3e, cfg + 9, 2);
1053 }
1054 
1055 static void dib0090_set_bbramp(struct dib0090_state *state, const u16 * cfg)
1056 {
1057 	state->bb_ramp = cfg;
1058 	dib0090_set_boost(state, cfg[0] > 500);	/* we want the boost if the gain is higher that 50dB */
1059 }
1060 
1061 static void dib0090_set_bbramp_pwm(struct dib0090_state *state, const u16 * cfg)
1062 {
1063 	state->bb_ramp = cfg;
1064 
1065 	dib0090_set_boost(state, cfg[0] > 500);	/* we want the boost if the gain is higher that 50dB */
1066 
1067 	dib0090_write_reg(state, 0x33, 0xffff);
1068 	dprintk("total BB gain: %ddB, step: %d\n", (u32) cfg[0], dib0090_read_reg(state, 0x33));
1069 	dib0090_write_regs(state, 0x35, cfg + 3, 4);
1070 }
1071 
1072 void dib0090_pwm_gain_reset(struct dvb_frontend *fe)
1073 {
1074 	struct dib0090_state *state = fe->tuner_priv;
1075 	u16 *bb_ramp = (u16 *)&bb_ramp_pwm_normal; /* default baseband config */
1076 	u16 *rf_ramp = NULL;
1077 	u8 en_pwm_rf_mux = 1;
1078 
1079 	/* reset the AGC */
1080 	if (state->config->use_pwm_agc) {
1081 		if (state->current_band == BAND_CBAND) {
1082 			if (state->identity.in_soc) {
1083 				bb_ramp = (u16 *)&bb_ramp_pwm_normal_socs;
1084 				if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1)
1085 					rf_ramp = (u16 *)&rf_ramp_pwm_cband_8090;
1086 				else if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1) {
1087 					if (state->config->is_dib7090e) {
1088 						if (state->rf_ramp == NULL)
1089 							rf_ramp = (u16 *)&rf_ramp_pwm_cband_7090e_sensitivity;
1090 						else
1091 							rf_ramp = (u16 *)state->rf_ramp;
1092 					} else
1093 						rf_ramp = (u16 *)&rf_ramp_pwm_cband_7090p;
1094 				}
1095 			} else
1096 				rf_ramp = (u16 *)&rf_ramp_pwm_cband;
1097 		} else
1098 
1099 			if (state->current_band == BAND_VHF) {
1100 				if (state->identity.in_soc) {
1101 					bb_ramp = (u16 *)&bb_ramp_pwm_normal_socs;
1102 					/* rf_ramp = &rf_ramp_pwm_vhf_socs; */ /* TODO */
1103 				} else
1104 					rf_ramp = (u16 *)&rf_ramp_pwm_vhf;
1105 			} else if (state->current_band == BAND_UHF) {
1106 				if (state->identity.in_soc) {
1107 					bb_ramp = (u16 *)&bb_ramp_pwm_normal_socs;
1108 					if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1)
1109 						rf_ramp = (u16 *)&rf_ramp_pwm_uhf_8090;
1110 					else if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1)
1111 						rf_ramp = (u16 *)&rf_ramp_pwm_uhf_7090;
1112 				} else
1113 					rf_ramp = (u16 *)&rf_ramp_pwm_uhf;
1114 			}
1115 		if (rf_ramp)
1116 			dib0090_set_rframp_pwm(state, rf_ramp);
1117 		dib0090_set_bbramp_pwm(state, bb_ramp);
1118 
1119 		/* activate the ramp generator using PWM control */
1120 		if (state->rf_ramp)
1121 			dprintk("ramp RF gain = %d BAND = %s version = %d\n",
1122 				state->rf_ramp[0],
1123 				(state->current_band == BAND_CBAND) ? "CBAND" : "NOT CBAND",
1124 				state->identity.version & 0x1f);
1125 
1126 		if (rf_ramp && ((state->rf_ramp && state->rf_ramp[0] == 0) ||
1127 		    (state->current_band == BAND_CBAND &&
1128 		    (state->identity.version & 0x1f) <= P1D_E_F))) {
1129 			dprintk("DE-Engage mux for direct gain reg control\n");
1130 			en_pwm_rf_mux = 0;
1131 		} else
1132 			dprintk("Engage mux for PWM control\n");
1133 
1134 		dib0090_write_reg(state, 0x32, (en_pwm_rf_mux << 12) | (en_pwm_rf_mux << 11));
1135 
1136 		/* Set fast servo cutoff to start AGC; 0 = 1KHz ; 1 = 50Hz ; 2 = 150Hz ; 3 = 50KHz ; 4 = servo fast*/
1137 		if (state->identity.version == SOC_7090_P1G_11R1 || state->identity.version == SOC_7090_P1G_21R1)
1138 			dib0090_write_reg(state, 0x04, 3);
1139 		else
1140 			dib0090_write_reg(state, 0x04, 1);
1141 		dib0090_write_reg(state, 0x39, (1 << 10)); /* 0 gain by default */
1142 	}
1143 }
1144 EXPORT_SYMBOL(dib0090_pwm_gain_reset);
1145 
1146 void dib0090_set_dc_servo(struct dvb_frontend *fe, u8 DC_servo_cutoff)
1147 {
1148 	struct dib0090_state *state = fe->tuner_priv;
1149 	if (DC_servo_cutoff < 4)
1150 		dib0090_write_reg(state, 0x04, DC_servo_cutoff);
1151 }
1152 EXPORT_SYMBOL(dib0090_set_dc_servo);
1153 
1154 static u32 dib0090_get_slow_adc_val(struct dib0090_state *state)
1155 {
1156 	u16 adc_val = dib0090_read_reg(state, 0x1d);
1157 	if (state->identity.in_soc)
1158 		adc_val >>= 2;
1159 	return adc_val;
1160 }
1161 
1162 int dib0090_gain_control(struct dvb_frontend *fe)
1163 {
1164 	struct dib0090_state *state = fe->tuner_priv;
1165 	enum frontend_tune_state *tune_state = &state->tune_state;
1166 	int ret = 10;
1167 
1168 	u16 wbd_val = 0;
1169 	u8 apply_gain_immediatly = 1;
1170 	s16 wbd_error = 0, adc_error = 0;
1171 
1172 	if (*tune_state == CT_AGC_START) {
1173 		state->agc_freeze = 0;
1174 		dib0090_write_reg(state, 0x04, 0x0);
1175 
1176 #ifdef CONFIG_BAND_SBAND
1177 		if (state->current_band == BAND_SBAND) {
1178 			dib0090_set_rframp(state, rf_ramp_sband);
1179 			dib0090_set_bbramp(state, bb_ramp_boost);
1180 		} else
1181 #endif
1182 #ifdef CONFIG_BAND_VHF
1183 		if (state->current_band == BAND_VHF && !state->identity.p1g) {
1184 			dib0090_set_rframp(state, rf_ramp_pwm_vhf);
1185 			dib0090_set_bbramp(state, bb_ramp_pwm_normal);
1186 		} else
1187 #endif
1188 #ifdef CONFIG_BAND_CBAND
1189 		if (state->current_band == BAND_CBAND && !state->identity.p1g) {
1190 			dib0090_set_rframp(state, rf_ramp_pwm_cband);
1191 			dib0090_set_bbramp(state, bb_ramp_pwm_normal);
1192 		} else
1193 #endif
1194 		if ((state->current_band == BAND_CBAND || state->current_band == BAND_VHF) && state->identity.p1g) {
1195 			dib0090_set_rframp(state, rf_ramp_pwm_cband_7090p);
1196 			dib0090_set_bbramp(state, bb_ramp_pwm_normal_socs);
1197 		} else {
1198 			dib0090_set_rframp(state, rf_ramp_pwm_uhf);
1199 			dib0090_set_bbramp(state, bb_ramp_pwm_normal);
1200 		}
1201 
1202 		dib0090_write_reg(state, 0x32, 0);
1203 		dib0090_write_reg(state, 0x39, 0);
1204 
1205 		dib0090_wbd_target(state, state->current_rf);
1206 
1207 		state->rf_gain_limit = state->rf_ramp[0] << WBD_ALPHA;
1208 		state->current_gain = ((state->rf_ramp[0] + state->bb_ramp[0]) / 2) << GAIN_ALPHA;
1209 
1210 		*tune_state = CT_AGC_STEP_0;
1211 	} else if (!state->agc_freeze) {
1212 		s16 wbd = 0, i, cnt;
1213 
1214 		int adc;
1215 		wbd_val = dib0090_get_slow_adc_val(state);
1216 
1217 		if (*tune_state == CT_AGC_STEP_0)
1218 			cnt = 5;
1219 		else
1220 			cnt = 1;
1221 
1222 		for (i = 0; i < cnt; i++) {
1223 			wbd_val = dib0090_get_slow_adc_val(state);
1224 			wbd += dib0090_wbd_to_db(state, wbd_val);
1225 		}
1226 		wbd /= cnt;
1227 		wbd_error = state->wbd_target - wbd;
1228 
1229 		if (*tune_state == CT_AGC_STEP_0) {
1230 			if (wbd_error < 0 && state->rf_gain_limit > 0 && !state->identity.p1g) {
1231 #ifdef CONFIG_BAND_CBAND
1232 				/* in case of CBAND tune reduce first the lt_gain2 before adjusting the RF gain */
1233 				u8 ltg2 = (state->rf_lt_def >> 10) & 0x7;
1234 				if (state->current_band == BAND_CBAND && ltg2) {
1235 					ltg2 >>= 1;
1236 					state->rf_lt_def &= ltg2 << 10;	/* reduce in 3 steps from 7 to 0 */
1237 				}
1238 #endif
1239 			} else {
1240 				state->agc_step = 0;
1241 				*tune_state = CT_AGC_STEP_1;
1242 			}
1243 		} else {
1244 			/* calc the adc power */
1245 			adc = state->config->get_adc_power(fe);
1246 			adc = (adc * ((s32) 355774) + (((s32) 1) << 20)) >> 21;	/* included in [0:-700] */
1247 
1248 			adc_error = (s16) (((s32) ADC_TARGET) - adc);
1249 #ifdef CONFIG_STANDARD_DAB
1250 			if (state->fe->dtv_property_cache.delivery_system == STANDARD_DAB)
1251 				adc_error -= 10;
1252 #endif
1253 #ifdef CONFIG_STANDARD_DVBT
1254 			if (state->fe->dtv_property_cache.delivery_system == STANDARD_DVBT &&
1255 					(state->fe->dtv_property_cache.modulation == QAM_64 || state->fe->dtv_property_cache.modulation == QAM_16))
1256 				adc_error += 60;
1257 #endif
1258 #ifdef CONFIG_SYS_ISDBT
1259 			if ((state->fe->dtv_property_cache.delivery_system == SYS_ISDBT) && (((state->fe->dtv_property_cache.layer[0].segment_count >
1260 								0)
1261 							&&
1262 							((state->fe->dtv_property_cache.layer[0].modulation ==
1263 							  QAM_64)
1264 							 || (state->fe->dtv_property_cache.
1265 								 layer[0].modulation == QAM_16)))
1266 						||
1267 						((state->fe->dtv_property_cache.layer[1].segment_count >
1268 						  0)
1269 						 &&
1270 						 ((state->fe->dtv_property_cache.layer[1].modulation ==
1271 						   QAM_64)
1272 						  || (state->fe->dtv_property_cache.
1273 							  layer[1].modulation == QAM_16)))
1274 						||
1275 						((state->fe->dtv_property_cache.layer[2].segment_count >
1276 						  0)
1277 						 &&
1278 						 ((state->fe->dtv_property_cache.layer[2].modulation ==
1279 						   QAM_64)
1280 						  || (state->fe->dtv_property_cache.
1281 							  layer[2].modulation == QAM_16)))
1282 						)
1283 				)
1284 				adc_error += 60;
1285 #endif
1286 
1287 			if (*tune_state == CT_AGC_STEP_1) {	/* quickly go to the correct range of the ADC power */
1288 				if (ABS(adc_error) < 50 || state->agc_step++ > 5) {
1289 
1290 #ifdef CONFIG_STANDARD_DAB
1291 					if (state->fe->dtv_property_cache.delivery_system == STANDARD_DAB) {
1292 						dib0090_write_reg(state, 0x02, (1 << 15) | (15 << 11) | (31 << 6) | (63));	/* cap value = 63 : narrow BB filter : Fc = 1.8MHz */
1293 						dib0090_write_reg(state, 0x04, 0x0);
1294 					} else
1295 #endif
1296 					{
1297 						dib0090_write_reg(state, 0x02, (1 << 15) | (3 << 11) | (6 << 6) | (32));
1298 						dib0090_write_reg(state, 0x04, 0x01);	/*0 = 1KHz ; 1 = 150Hz ; 2 = 50Hz ; 3 = 50KHz ; 4 = servo fast */
1299 					}
1300 
1301 					*tune_state = CT_AGC_STOP;
1302 				}
1303 			} else {
1304 				/* everything higher than or equal to CT_AGC_STOP means tracking */
1305 				ret = 100;	/* 10ms interval */
1306 				apply_gain_immediatly = 0;
1307 			}
1308 		}
1309 #ifdef DEBUG_AGC
1310 		dprintk
1311 			("tune state %d, ADC = %3ddB (ADC err %3d) WBD %3ddB (WBD err %3d, WBD val SADC: %4d), RFGainLimit (TOP): %3d, signal: %3ddBm",
1312 			 (u32) *tune_state, (u32) adc, (u32) adc_error, (u32) wbd, (u32) wbd_error, (u32) wbd_val,
1313 			 (u32) state->rf_gain_limit >> WBD_ALPHA, (s32) 200 + adc - (state->current_gain >> GAIN_ALPHA));
1314 #endif
1315 	}
1316 
1317 	/* apply gain */
1318 	if (!state->agc_freeze)
1319 		dib0090_gain_apply(state, adc_error, wbd_error, apply_gain_immediatly);
1320 	return ret;
1321 }
1322 
1323 EXPORT_SYMBOL(dib0090_gain_control);
1324 
1325 void dib0090_get_current_gain(struct dvb_frontend *fe, u16 * rf, u16 * bb, u16 * rf_gain_limit, u16 * rflt)
1326 {
1327 	struct dib0090_state *state = fe->tuner_priv;
1328 	if (rf)
1329 		*rf = state->gain[0];
1330 	if (bb)
1331 		*bb = state->gain[1];
1332 	if (rf_gain_limit)
1333 		*rf_gain_limit = state->rf_gain_limit;
1334 	if (rflt)
1335 		*rflt = (state->rf_lt_def >> 10) & 0x7;
1336 }
1337 
1338 EXPORT_SYMBOL(dib0090_get_current_gain);
1339 
1340 u16 dib0090_get_wbd_target(struct dvb_frontend *fe)
1341 {
1342 	struct dib0090_state *state = fe->tuner_priv;
1343 	u32 f_MHz = state->fe->dtv_property_cache.frequency / 1000000;
1344 	s32 current_temp = state->temperature;
1345 	s32 wbd_thot, wbd_tcold;
1346 	const struct dib0090_wbd_slope *wbd = state->current_wbd_table;
1347 
1348 	while (f_MHz > wbd->max_freq)
1349 		wbd++;
1350 
1351 	dprintk("using wbd-table-entry with max freq %d\n", wbd->max_freq);
1352 
1353 	if (current_temp < 0)
1354 		current_temp = 0;
1355 	if (current_temp > 128)
1356 		current_temp = 128;
1357 
1358 	state->wbdmux &= ~(7 << 13);
1359 	if (wbd->wbd_gain != 0)
1360 		state->wbdmux |= (wbd->wbd_gain << 13);
1361 	else
1362 		state->wbdmux |= (4 << 13);
1363 
1364 	dib0090_write_reg(state, 0x10, state->wbdmux);
1365 
1366 	wbd_thot = wbd->offset_hot - (((u32) wbd->slope_hot * f_MHz) >> 6);
1367 	wbd_tcold = wbd->offset_cold - (((u32) wbd->slope_cold * f_MHz) >> 6);
1368 
1369 	wbd_tcold += ((wbd_thot - wbd_tcold) * current_temp) >> 7;
1370 
1371 	state->wbd_target = dib0090_wbd_to_db(state, state->wbd_offset + wbd_tcold);
1372 	dprintk("wbd-target: %d dB\n", (u32) state->wbd_target);
1373 	dprintk("wbd offset applied is %d\n", wbd_tcold);
1374 
1375 	return state->wbd_offset + wbd_tcold;
1376 }
1377 EXPORT_SYMBOL(dib0090_get_wbd_target);
1378 
1379 u16 dib0090_get_wbd_offset(struct dvb_frontend *fe)
1380 {
1381 	struct dib0090_state *state = fe->tuner_priv;
1382 	return state->wbd_offset;
1383 }
1384 EXPORT_SYMBOL(dib0090_get_wbd_offset);
1385 
1386 int dib0090_set_switch(struct dvb_frontend *fe, u8 sw1, u8 sw2, u8 sw3)
1387 {
1388 	struct dib0090_state *state = fe->tuner_priv;
1389 
1390 	dib0090_write_reg(state, 0x0b, (dib0090_read_reg(state, 0x0b) & 0xfff8)
1391 			| ((sw3 & 1) << 2) | ((sw2 & 1) << 1) | (sw1 & 1));
1392 
1393 	return 0;
1394 }
1395 EXPORT_SYMBOL(dib0090_set_switch);
1396 
1397 int dib0090_set_vga(struct dvb_frontend *fe, u8 onoff)
1398 {
1399 	struct dib0090_state *state = fe->tuner_priv;
1400 
1401 	dib0090_write_reg(state, 0x09, (dib0090_read_reg(state, 0x09) & 0x7fff)
1402 			| ((onoff & 1) << 15));
1403 	return 0;
1404 }
1405 EXPORT_SYMBOL(dib0090_set_vga);
1406 
1407 int dib0090_update_rframp_7090(struct dvb_frontend *fe, u8 cfg_sensitivity)
1408 {
1409 	struct dib0090_state *state = fe->tuner_priv;
1410 
1411 	if ((!state->identity.p1g) || (!state->identity.in_soc)
1412 			|| ((state->identity.version != SOC_7090_P1G_21R1)
1413 				&& (state->identity.version != SOC_7090_P1G_11R1))) {
1414 		dprintk("%s() function can only be used for dib7090P\n", __func__);
1415 		return -ENODEV;
1416 	}
1417 
1418 	if (cfg_sensitivity)
1419 		state->rf_ramp = (const u16 *)&rf_ramp_pwm_cband_7090e_sensitivity;
1420 	else
1421 		state->rf_ramp = (const u16 *)&rf_ramp_pwm_cband_7090e_aci;
1422 	dib0090_pwm_gain_reset(fe);
1423 
1424 	return 0;
1425 }
1426 EXPORT_SYMBOL(dib0090_update_rframp_7090);
1427 
1428 static const u16 dib0090_defaults[] = {
1429 
1430 	25, 0x01,
1431 	0x0000,
1432 	0x99a0,
1433 	0x6008,
1434 	0x0000,
1435 	0x8bcb,
1436 	0x0000,
1437 	0x0405,
1438 	0x0000,
1439 	0x0000,
1440 	0x0000,
1441 	0xb802,
1442 	0x0300,
1443 	0x2d12,
1444 	0xbac0,
1445 	0x7c00,
1446 	0xdbb9,
1447 	0x0954,
1448 	0x0743,
1449 	0x8000,
1450 	0x0001,
1451 	0x0040,
1452 	0x0100,
1453 	0x0000,
1454 	0xe910,
1455 	0x149e,
1456 
1457 	1, 0x1c,
1458 	0xff2d,
1459 
1460 	1, 0x39,
1461 	0x0000,
1462 
1463 	2, 0x1e,
1464 	0x07FF,
1465 	0x0007,
1466 
1467 	1, 0x24,
1468 	EN_UHF | EN_CRYSTAL,
1469 
1470 	2, 0x3c,
1471 	0x3ff,
1472 	0x111,
1473 	0
1474 };
1475 
1476 static const u16 dib0090_p1g_additionnal_defaults[] = {
1477 	1, 0x05,
1478 	0xabcd,
1479 
1480 	1, 0x11,
1481 	0x00b4,
1482 
1483 	1, 0x1c,
1484 	0xfffd,
1485 
1486 	1, 0x40,
1487 	0x108,
1488 	0
1489 };
1490 
1491 static void dib0090_set_default_config(struct dib0090_state *state, const u16 * n)
1492 {
1493 	u16 l, r;
1494 
1495 	l = pgm_read_word(n++);
1496 	while (l) {
1497 		r = pgm_read_word(n++);
1498 		do {
1499 			dib0090_write_reg(state, r, pgm_read_word(n++));
1500 			r++;
1501 		} while (--l);
1502 		l = pgm_read_word(n++);
1503 	}
1504 }
1505 
1506 #define CAP_VALUE_MIN (u8)  9
1507 #define CAP_VALUE_MAX (u8) 40
1508 #define HR_MIN	      (u8) 25
1509 #define HR_MAX	      (u8) 40
1510 #define POLY_MIN      (u8)  0
1511 #define POLY_MAX      (u8)  8
1512 
1513 static void dib0090_set_EFUSE(struct dib0090_state *state)
1514 {
1515 	u8 c, h, n;
1516 	u16 e2, e4;
1517 	u16 cal;
1518 
1519 	e2 = dib0090_read_reg(state, 0x26);
1520 	e4 = dib0090_read_reg(state, 0x28);
1521 
1522 	if ((state->identity.version == P1D_E_F) ||
1523 			(state->identity.version == P1G) || (e2 == 0xffff)) {
1524 
1525 		dib0090_write_reg(state, 0x22, 0x10);
1526 		cal = (dib0090_read_reg(state, 0x22) >> 6) & 0x3ff;
1527 
1528 		if ((cal < 670) || (cal == 1023))
1529 			cal = 850;
1530 		n = 165 - ((cal * 10)>>6) ;
1531 		e2 = e4 = (3<<12) | (34<<6) | (n);
1532 	}
1533 
1534 	if (e2 != e4)
1535 		e2 &= e4; /* Remove the redundancy  */
1536 
1537 	if (e2 != 0xffff) {
1538 		c = e2 & 0x3f;
1539 		n = (e2 >> 12) & 0xf;
1540 		h = (e2 >> 6) & 0x3f;
1541 
1542 		if ((c >= CAP_VALUE_MAX) || (c <= CAP_VALUE_MIN))
1543 			c = 32;
1544 		else
1545 			c += 14;
1546 		if ((h >= HR_MAX) || (h <= HR_MIN))
1547 			h = 34;
1548 		if ((n >= POLY_MAX) || (n <= POLY_MIN))
1549 			n = 3;
1550 
1551 		dib0090_write_reg(state, 0x13, (h << 10));
1552 		e2 = (n << 11) | ((h >> 2)<<6) | c;
1553 		dib0090_write_reg(state, 0x2, e2); /* Load the BB_2 */
1554 	}
1555 }
1556 
1557 static int dib0090_reset(struct dvb_frontend *fe)
1558 {
1559 	struct dib0090_state *state = fe->tuner_priv;
1560 
1561 	dib0090_reset_digital(fe, state->config);
1562 	if (dib0090_identify(fe) < 0)
1563 		return -EIO;
1564 
1565 #ifdef CONFIG_TUNER_DIB0090_P1B_SUPPORT
1566 	if (!(state->identity.version & 0x1))	/* it is P1B - reset is already done */
1567 		return 0;
1568 #endif
1569 
1570 	if (!state->identity.in_soc) {
1571 		if ((dib0090_read_reg(state, 0x1a) >> 5) & 0x2)
1572 			dib0090_write_reg(state, 0x1b, (EN_IQADC | EN_BB | EN_BIAS | EN_DIGCLK | EN_PLL | EN_CRYSTAL));
1573 		else
1574 			dib0090_write_reg(state, 0x1b, (EN_DIGCLK | EN_PLL | EN_CRYSTAL));
1575 	}
1576 
1577 	dib0090_set_default_config(state, dib0090_defaults);
1578 
1579 	if (state->identity.in_soc)
1580 		dib0090_write_reg(state, 0x18, 0x2910);  /* charge pump current = 0 */
1581 
1582 	if (state->identity.p1g)
1583 		dib0090_set_default_config(state, dib0090_p1g_additionnal_defaults);
1584 
1585 	/* Update the efuse : Only available for KROSUS > P1C  and SOC as well*/
1586 	if (((state->identity.version & 0x1f) >= P1D_E_F) || (state->identity.in_soc))
1587 		dib0090_set_EFUSE(state);
1588 
1589 	/* Congigure in function of the crystal */
1590 	if (state->config->force_crystal_mode != 0)
1591 		dib0090_write_reg(state, 0x14,
1592 				state->config->force_crystal_mode & 3);
1593 	else if (state->config->io.clock_khz >= 24000)
1594 		dib0090_write_reg(state, 0x14, 1);
1595 	else
1596 		dib0090_write_reg(state, 0x14, 2);
1597 	dprintk("Pll lock : %d\n", (dib0090_read_reg(state, 0x1a) >> 11) & 0x1);
1598 
1599 	state->calibrate = DC_CAL | WBD_CAL | TEMP_CAL;	/* enable iq-offset-calibration and wbd-calibration when tuning next time */
1600 
1601 	return 0;
1602 }
1603 
1604 #define steps(u) (((u) > 15) ? ((u)-16) : (u))
1605 #define INTERN_WAIT 10
1606 static int dib0090_get_offset(struct dib0090_state *state, enum frontend_tune_state *tune_state)
1607 {
1608 	int ret = INTERN_WAIT * 10;
1609 
1610 	switch (*tune_state) {
1611 	case CT_TUNER_STEP_2:
1612 		/* Turns to positive */
1613 		dib0090_write_reg(state, 0x1f, 0x7);
1614 		*tune_state = CT_TUNER_STEP_3;
1615 		break;
1616 
1617 	case CT_TUNER_STEP_3:
1618 		state->adc_diff = dib0090_read_reg(state, 0x1d);
1619 
1620 		/* Turns to negative */
1621 		dib0090_write_reg(state, 0x1f, 0x4);
1622 		*tune_state = CT_TUNER_STEP_4;
1623 		break;
1624 
1625 	case CT_TUNER_STEP_4:
1626 		state->adc_diff -= dib0090_read_reg(state, 0x1d);
1627 		*tune_state = CT_TUNER_STEP_5;
1628 		ret = 0;
1629 		break;
1630 
1631 	default:
1632 		break;
1633 	}
1634 
1635 	return ret;
1636 }
1637 
1638 struct dc_calibration {
1639 	u8 addr;
1640 	u8 offset;
1641 	u8 pga:1;
1642 	u16 bb1;
1643 	u8 i:1;
1644 };
1645 
1646 static const struct dc_calibration dc_table[] = {
1647 	/* Step1 BB gain1= 26 with boost 1, gain 2 = 0 */
1648 	{0x06, 5, 1, (1 << 13) | (0 << 8) | (26 << 3), 1},
1649 	{0x07, 11, 1, (1 << 13) | (0 << 8) | (26 << 3), 0},
1650 	/* Step 2 BB gain 1 = 26 with boost = 1 & gain 2 = 29 */
1651 	{0x06, 0, 0, (1 << 13) | (29 << 8) | (26 << 3), 1},
1652 	{0x06, 10, 0, (1 << 13) | (29 << 8) | (26 << 3), 0},
1653 	{0},
1654 };
1655 
1656 static const struct dc_calibration dc_p1g_table[] = {
1657 	/* Step1 BB gain1= 26 with boost 1, gain 2 = 0 */
1658 	/* addr ; trim reg offset ; pga ; CTRL_BB1 value ; i or q */
1659 	{0x06, 5, 1, (1 << 13) | (0 << 8) | (15 << 3), 1},
1660 	{0x07, 11, 1, (1 << 13) | (0 << 8) | (15 << 3), 0},
1661 	/* Step 2 BB gain 1 = 26 with boost = 1 & gain 2 = 29 */
1662 	{0x06, 0, 0, (1 << 13) | (29 << 8) | (15 << 3), 1},
1663 	{0x06, 10, 0, (1 << 13) | (29 << 8) | (15 << 3), 0},
1664 	{0},
1665 };
1666 
1667 static void dib0090_set_trim(struct dib0090_state *state)
1668 {
1669 	u16 *val;
1670 
1671 	if (state->dc->addr == 0x07)
1672 		val = &state->bb7;
1673 	else
1674 		val = &state->bb6;
1675 
1676 	*val &= ~(0x1f << state->dc->offset);
1677 	*val |= state->step << state->dc->offset;
1678 
1679 	dib0090_write_reg(state, state->dc->addr, *val);
1680 }
1681 
1682 static int dib0090_dc_offset_calibration(struct dib0090_state *state, enum frontend_tune_state *tune_state)
1683 {
1684 	int ret = 0;
1685 	u16 reg;
1686 
1687 	switch (*tune_state) {
1688 	case CT_TUNER_START:
1689 		dprintk("Start DC offset calibration");
1690 
1691 		/* force vcm2 = 0.8V */
1692 		state->bb6 = 0;
1693 		state->bb7 = 0x040d;
1694 
1695 		/* the LNA AND LO are off */
1696 		reg = dib0090_read_reg(state, 0x24) & 0x0ffb;	/* shutdown lna and lo */
1697 		dib0090_write_reg(state, 0x24, reg);
1698 
1699 		state->wbdmux = dib0090_read_reg(state, 0x10);
1700 		dib0090_write_reg(state, 0x10, (state->wbdmux & ~(0xff << 3)) | (0x7 << 3) | 0x3);
1701 		dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) & ~(1 << 14));
1702 
1703 		state->dc = dc_table;
1704 
1705 		if (state->identity.p1g)
1706 			state->dc = dc_p1g_table;
1707 
1708 		/* fall through */
1709 	case CT_TUNER_STEP_0:
1710 		dprintk("Start/continue DC calibration for %s path\n",
1711 			(state->dc->i == 1) ? "I" : "Q");
1712 		dib0090_write_reg(state, 0x01, state->dc->bb1);
1713 		dib0090_write_reg(state, 0x07, state->bb7 | (state->dc->i << 7));
1714 
1715 		state->step = 0;
1716 		state->min_adc_diff = 1023;
1717 		*tune_state = CT_TUNER_STEP_1;
1718 		ret = 50;
1719 		break;
1720 
1721 	case CT_TUNER_STEP_1:
1722 		dib0090_set_trim(state);
1723 		*tune_state = CT_TUNER_STEP_2;
1724 		break;
1725 
1726 	case CT_TUNER_STEP_2:
1727 	case CT_TUNER_STEP_3:
1728 	case CT_TUNER_STEP_4:
1729 		ret = dib0090_get_offset(state, tune_state);
1730 		break;
1731 
1732 	case CT_TUNER_STEP_5:	/* found an offset */
1733 		dprintk("adc_diff = %d, current step= %d\n", (u32) state->adc_diff, state->step);
1734 		if (state->step == 0 && state->adc_diff < 0) {
1735 			state->min_adc_diff = -1023;
1736 			dprintk("Change of sign of the minimum adc diff\n");
1737 		}
1738 
1739 		dprintk("adc_diff = %d, min_adc_diff = %d current_step = %d\n", state->adc_diff, state->min_adc_diff, state->step);
1740 
1741 		/* first turn for this frequency */
1742 		if (state->step == 0) {
1743 			if (state->dc->pga && state->adc_diff < 0)
1744 				state->step = 0x10;
1745 			if (state->dc->pga == 0 && state->adc_diff > 0)
1746 				state->step = 0x10;
1747 		}
1748 
1749 		/* Look for a change of Sign in the Adc_diff.min_adc_diff is used to STORE the setp N-1 */
1750 		if ((state->adc_diff & 0x8000) == (state->min_adc_diff & 0x8000) && steps(state->step) < 15) {
1751 			/* stop search when the delta the sign is changing and Steps =15 and Step=0 is force for continuance */
1752 			state->step++;
1753 			state->min_adc_diff = state->adc_diff;
1754 			*tune_state = CT_TUNER_STEP_1;
1755 		} else {
1756 			/* the minimum was what we have seen in the step before */
1757 			if (ABS(state->adc_diff) > ABS(state->min_adc_diff)) {
1758 				dprintk("Since adc_diff N = %d  > adc_diff step N-1 = %d, Come back one step\n", state->adc_diff, state->min_adc_diff);
1759 				state->step--;
1760 			}
1761 
1762 			dib0090_set_trim(state);
1763 			dprintk("BB Offset Cal, BBreg=%hd,Offset=%hd,Value Set=%hd\n", state->dc->addr, state->adc_diff, state->step);
1764 
1765 			state->dc++;
1766 			if (state->dc->addr == 0)	/* done */
1767 				*tune_state = CT_TUNER_STEP_6;
1768 			else
1769 				*tune_state = CT_TUNER_STEP_0;
1770 
1771 		}
1772 		break;
1773 
1774 	case CT_TUNER_STEP_6:
1775 		dib0090_write_reg(state, 0x07, state->bb7 & ~0x0008);
1776 		dib0090_write_reg(state, 0x1f, 0x7);
1777 		*tune_state = CT_TUNER_START;	/* reset done -> real tuning can now begin */
1778 		state->calibrate &= ~DC_CAL;
1779 	default:
1780 		break;
1781 	}
1782 	return ret;
1783 }
1784 
1785 static int dib0090_wbd_calibration(struct dib0090_state *state, enum frontend_tune_state *tune_state)
1786 {
1787 	u8 wbd_gain;
1788 	const struct dib0090_wbd_slope *wbd = state->current_wbd_table;
1789 
1790 	switch (*tune_state) {
1791 	case CT_TUNER_START:
1792 		while (state->current_rf / 1000 > wbd->max_freq)
1793 			wbd++;
1794 		if (wbd->wbd_gain != 0)
1795 			wbd_gain = wbd->wbd_gain;
1796 		else {
1797 			wbd_gain = 4;
1798 #if defined(CONFIG_BAND_LBAND) || defined(CONFIG_BAND_SBAND)
1799 			if ((state->current_band == BAND_LBAND) || (state->current_band == BAND_SBAND))
1800 				wbd_gain = 2;
1801 #endif
1802 		}
1803 
1804 		if (wbd_gain == state->wbd_calibration_gain) {	/* the WBD calibration has already been done */
1805 			*tune_state = CT_TUNER_START;
1806 			state->calibrate &= ~WBD_CAL;
1807 			return 0;
1808 		}
1809 
1810 		dib0090_write_reg(state, 0x10, 0x1b81 | (1 << 10) | (wbd_gain << 13) | (1 << 3));
1811 
1812 		dib0090_write_reg(state, 0x24, ((EN_UHF & 0x0fff) | (1 << 1)));
1813 		*tune_state = CT_TUNER_STEP_0;
1814 		state->wbd_calibration_gain = wbd_gain;
1815 		return 90;	/* wait for the WBDMUX to switch and for the ADC to sample */
1816 
1817 	case CT_TUNER_STEP_0:
1818 		state->wbd_offset = dib0090_get_slow_adc_val(state);
1819 		dprintk("WBD calibration offset = %d\n", state->wbd_offset);
1820 		*tune_state = CT_TUNER_START;	/* reset done -> real tuning can now begin */
1821 		state->calibrate &= ~WBD_CAL;
1822 		break;
1823 
1824 	default:
1825 		break;
1826 	}
1827 	return 0;
1828 }
1829 
1830 static void dib0090_set_bandwidth(struct dib0090_state *state)
1831 {
1832 	u16 tmp;
1833 
1834 	if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 5000)
1835 		tmp = (3 << 14);
1836 	else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 6000)
1837 		tmp = (2 << 14);
1838 	else if (state->fe->dtv_property_cache.bandwidth_hz / 1000 <= 7000)
1839 		tmp = (1 << 14);
1840 	else
1841 		tmp = (0 << 14);
1842 
1843 	state->bb_1_def &= 0x3fff;
1844 	state->bb_1_def |= tmp;
1845 
1846 	dib0090_write_reg(state, 0x01, state->bb_1_def);	/* be sure that we have the right bb-filter */
1847 
1848 	dib0090_write_reg(state, 0x03, 0x6008);	/* = 0x6008 : vcm3_trim = 1 ; filter2_gm1_trim = 8 ; filter2_cutoff_freq = 0 */
1849 	dib0090_write_reg(state, 0x04, 0x1);	/* 0 = 1KHz ; 1 = 50Hz ; 2 = 150Hz ; 3 = 50KHz ; 4 = servo fast */
1850 	if (state->identity.in_soc) {
1851 		dib0090_write_reg(state, 0x05, 0x9bcf); /* attenuator_ibias_tri = 2 ; input_stage_ibias_tr = 1 ; nc = 11 ; ext_gm_trim = 1 ; obuf_ibias_trim = 4 ; filter13_gm2_ibias_t = 15 */
1852 	} else {
1853 		dib0090_write_reg(state, 0x02, (5 << 11) | (8 << 6) | (22 & 0x3f));	/* 22 = cap_value */
1854 		dib0090_write_reg(state, 0x05, 0xabcd);	/* = 0xabcd : attenuator_ibias_tri = 2 ; input_stage_ibias_tr = 2 ; nc = 11 ; ext_gm_trim = 1 ; obuf_ibias_trim = 4 ; filter13_gm2_ibias_t = 13 */
1855 	}
1856 }
1857 
1858 static const struct dib0090_pll dib0090_pll_table[] = {
1859 #ifdef CONFIG_BAND_CBAND
1860 	{56000, 0, 9, 48, 6},
1861 	{70000, 1, 9, 48, 6},
1862 	{87000, 0, 8, 32, 4},
1863 	{105000, 1, 8, 32, 4},
1864 	{115000, 0, 7, 24, 6},
1865 	{140000, 1, 7, 24, 6},
1866 	{170000, 0, 6, 16, 4},
1867 #endif
1868 #ifdef CONFIG_BAND_VHF
1869 	{200000, 1, 6, 16, 4},
1870 	{230000, 0, 5, 12, 6},
1871 	{280000, 1, 5, 12, 6},
1872 	{340000, 0, 4, 8, 4},
1873 	{380000, 1, 4, 8, 4},
1874 	{450000, 0, 3, 6, 6},
1875 #endif
1876 #ifdef CONFIG_BAND_UHF
1877 	{580000, 1, 3, 6, 6},
1878 	{700000, 0, 2, 4, 4},
1879 	{860000, 1, 2, 4, 4},
1880 #endif
1881 #ifdef CONFIG_BAND_LBAND
1882 	{1800000, 1, 0, 2, 4},
1883 #endif
1884 #ifdef CONFIG_BAND_SBAND
1885 	{2900000, 0, 14, 1, 4},
1886 #endif
1887 };
1888 
1889 static const struct dib0090_tuning dib0090_tuning_table_fm_vhf_on_cband[] = {
1890 
1891 #ifdef CONFIG_BAND_CBAND
1892 	{184000, 4, 1, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1893 	{227000, 4, 3, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1894 	{380000, 4, 7, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1895 #endif
1896 #ifdef CONFIG_BAND_UHF
1897 	{520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1898 	{550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1899 	{650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1900 	{750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1901 	{850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1902 	{900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1903 #endif
1904 #ifdef CONFIG_BAND_LBAND
1905 	{1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1906 	{1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1907 	{1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1908 #endif
1909 #ifdef CONFIG_BAND_SBAND
1910 	{2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
1911 	{2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
1912 #endif
1913 };
1914 
1915 static const struct dib0090_tuning dib0090_tuning_table[] = {
1916 
1917 #ifdef CONFIG_BAND_CBAND
1918 	{170000, 4, 1, 15, 0x280, 0x2912, 0xb94e, EN_CAB},
1919 #endif
1920 #ifdef CONFIG_BAND_VHF
1921 	{184000, 1, 1, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1922 	{227000, 1, 3, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1923 	{380000, 1, 7, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1924 #endif
1925 #ifdef CONFIG_BAND_UHF
1926 	{520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1927 	{550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1928 	{650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1929 	{750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1930 	{850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1931 	{900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1932 #endif
1933 #ifdef CONFIG_BAND_LBAND
1934 	{1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1935 	{1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1936 	{1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1937 #endif
1938 #ifdef CONFIG_BAND_SBAND
1939 	{2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
1940 	{2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
1941 #endif
1942 };
1943 
1944 static const struct dib0090_tuning dib0090_p1g_tuning_table[] = {
1945 #ifdef CONFIG_BAND_CBAND
1946 	{170000, 4, 1, 0x820f, 0x300, 0x2d22, 0x82cb, EN_CAB},
1947 #endif
1948 #ifdef CONFIG_BAND_VHF
1949 	{184000, 1, 1, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1950 	{227000, 1, 3, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1951 	{380000, 1, 7, 15, 0x300, 0x4d12, 0xb94e, EN_VHF},
1952 #endif
1953 #ifdef CONFIG_BAND_UHF
1954 	{510000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1955 	{540000, 2, 1, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1956 	{600000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1957 	{630000, 2, 4, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1958 	{680000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1959 	{720000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1960 	{900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
1961 #endif
1962 #ifdef CONFIG_BAND_LBAND
1963 	{1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1964 	{1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1965 	{1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
1966 #endif
1967 #ifdef CONFIG_BAND_SBAND
1968 	{2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
1969 	{2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
1970 #endif
1971 };
1972 
1973 static const struct dib0090_pll dib0090_p1g_pll_table[] = {
1974 #ifdef CONFIG_BAND_CBAND
1975 	{57000, 0, 11, 48, 6},
1976 	{70000, 1, 11, 48, 6},
1977 	{86000, 0, 10, 32, 4},
1978 	{105000, 1, 10, 32, 4},
1979 	{115000, 0, 9, 24, 6},
1980 	{140000, 1, 9, 24, 6},
1981 	{170000, 0, 8, 16, 4},
1982 #endif
1983 #ifdef CONFIG_BAND_VHF
1984 	{200000, 1, 8, 16, 4},
1985 	{230000, 0, 7, 12, 6},
1986 	{280000, 1, 7, 12, 6},
1987 	{340000, 0, 6, 8, 4},
1988 	{380000, 1, 6, 8, 4},
1989 	{455000, 0, 5, 6, 6},
1990 #endif
1991 #ifdef CONFIG_BAND_UHF
1992 	{580000, 1, 5, 6, 6},
1993 	{680000, 0, 4, 4, 4},
1994 	{860000, 1, 4, 4, 4},
1995 #endif
1996 #ifdef CONFIG_BAND_LBAND
1997 	{1800000, 1, 2, 2, 4},
1998 #endif
1999 #ifdef CONFIG_BAND_SBAND
2000 	{2900000, 0, 1, 1, 6},
2001 #endif
2002 };
2003 
2004 static const struct dib0090_tuning dib0090_p1g_tuning_table_fm_vhf_on_cband[] = {
2005 #ifdef CONFIG_BAND_CBAND
2006 	{184000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB},
2007 	{227000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB},
2008 	{380000, 4, 3, 0x4187, 0x2c0, 0x2d22, 0x81cb, EN_CAB},
2009 #endif
2010 #ifdef CONFIG_BAND_UHF
2011 	{520000, 2, 0, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2012 	{550000, 2, 2, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2013 	{650000, 2, 3, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2014 	{750000, 2, 5, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2015 	{850000, 2, 6, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2016 	{900000, 2, 7, 15, 0x300, 0x1d12, 0xb9ce, EN_UHF},
2017 #endif
2018 #ifdef CONFIG_BAND_LBAND
2019 	{1500000, 4, 0, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
2020 	{1600000, 4, 1, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
2021 	{1800000, 4, 3, 20, 0x300, 0x1912, 0x82c9, EN_LBD},
2022 #endif
2023 #ifdef CONFIG_BAND_SBAND
2024 	{2300000, 1, 4, 20, 0x300, 0x2d2A, 0x82c7, EN_SBD},
2025 	{2900000, 1, 7, 20, 0x280, 0x2deb, 0x8347, EN_SBD},
2026 #endif
2027 };
2028 
2029 static const struct dib0090_tuning dib0090_tuning_table_cband_7090[] = {
2030 #ifdef CONFIG_BAND_CBAND
2031 	{300000, 4, 3, 0x018F, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2032 	{380000, 4, 10, 0x018F, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2033 	{570000, 4, 10, 0x8190, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2034 	{858000, 4, 5, 0x8190, 0x2c0, 0x2d22, 0xb9ce, EN_CAB},
2035 #endif
2036 };
2037 
2038 static const struct dib0090_tuning dib0090_tuning_table_cband_7090e_sensitivity[] = {
2039 #ifdef CONFIG_BAND_CBAND
2040 	{ 300000,  0 ,  3,  0x8105, 0x2c0, 0x2d12, 0xb84e, EN_CAB },
2041 	{ 380000,  0 ,  10, 0x810F, 0x2c0, 0x2d12, 0xb84e, EN_CAB },
2042 	{ 600000,  0 ,  10, 0x815E, 0x280, 0x2d12, 0xb84e, EN_CAB },
2043 	{ 660000,  0 ,  5,  0x85E3, 0x280, 0x2d12, 0xb84e, EN_CAB },
2044 	{ 720000,  0 ,  5,  0x852E, 0x280, 0x2d12, 0xb84e, EN_CAB },
2045 	{ 860000,  0 ,  4,  0x85E5, 0x280, 0x2d12, 0xb84e, EN_CAB },
2046 #endif
2047 };
2048 
2049 int dib0090_update_tuning_table_7090(struct dvb_frontend *fe,
2050 		u8 cfg_sensitivity)
2051 {
2052 	struct dib0090_state *state = fe->tuner_priv;
2053 	const struct dib0090_tuning *tune =
2054 		dib0090_tuning_table_cband_7090e_sensitivity;
2055 	static const struct dib0090_tuning dib0090_tuning_table_cband_7090e_aci[] = {
2056 		{ 300000,  0 ,  3,  0x8165, 0x2c0, 0x2d12, 0xb84e, EN_CAB },
2057 		{ 650000,  0 ,  4,  0x815B, 0x280, 0x2d12, 0xb84e, EN_CAB },
2058 		{ 860000,  0 ,  5,  0x84EF, 0x280, 0x2d12, 0xb84e, EN_CAB },
2059 	};
2060 
2061 	if ((!state->identity.p1g) || (!state->identity.in_soc)
2062 			|| ((state->identity.version != SOC_7090_P1G_21R1)
2063 				&& (state->identity.version != SOC_7090_P1G_11R1))) {
2064 		dprintk("%s() function can only be used for dib7090\n", __func__);
2065 		return -ENODEV;
2066 	}
2067 
2068 	if (cfg_sensitivity)
2069 		tune = dib0090_tuning_table_cband_7090e_sensitivity;
2070 	else
2071 		tune = dib0090_tuning_table_cband_7090e_aci;
2072 
2073 	while (state->rf_request > tune->max_freq)
2074 		tune++;
2075 
2076 	dib0090_write_reg(state, 0x09, (dib0090_read_reg(state, 0x09) & 0x8000)
2077 			| (tune->lna_bias & 0x7fff));
2078 	dib0090_write_reg(state, 0x0b, (dib0090_read_reg(state, 0x0b) & 0xf83f)
2079 			| ((tune->lna_tune << 6) & 0x07c0));
2080 	return 0;
2081 }
2082 EXPORT_SYMBOL(dib0090_update_tuning_table_7090);
2083 
2084 static int dib0090_captrim_search(struct dib0090_state *state, enum frontend_tune_state *tune_state)
2085 {
2086 	int ret = 0;
2087 	u16 lo4 = 0xe900;
2088 
2089 	s16 adc_target;
2090 	u16 adc;
2091 	s8 step_sign;
2092 	u8 force_soft_search = 0;
2093 
2094 	if (state->identity.version == SOC_8090_P1G_11R1 || state->identity.version == SOC_8090_P1G_21R1)
2095 		force_soft_search = 1;
2096 
2097 	if (*tune_state == CT_TUNER_START) {
2098 		dprintk("Start Captrim search : %s\n",
2099 			(force_soft_search == 1) ? "FORCE SOFT SEARCH" : "AUTO");
2100 		dib0090_write_reg(state, 0x10, 0x2B1);
2101 		dib0090_write_reg(state, 0x1e, 0x0032);
2102 
2103 		if (!state->tuner_is_tuned) {
2104 			/* prepare a complete captrim */
2105 			if (!state->identity.p1g || force_soft_search)
2106 				state->step = state->captrim = state->fcaptrim = 64;
2107 
2108 			state->current_rf = state->rf_request;
2109 		} else {	/* we are already tuned to this frequency - the configuration is correct  */
2110 			if (!state->identity.p1g || force_soft_search) {
2111 				/* do a minimal captrim even if the frequency has not changed */
2112 				state->step = 4;
2113 				state->captrim = state->fcaptrim = dib0090_read_reg(state, 0x18) & 0x7f;
2114 			}
2115 		}
2116 		state->adc_diff = 3000;
2117 		*tune_state = CT_TUNER_STEP_0;
2118 
2119 	} else if (*tune_state == CT_TUNER_STEP_0) {
2120 		if (state->identity.p1g && !force_soft_search) {
2121 			u8 ratio = 31;
2122 
2123 			dib0090_write_reg(state, 0x40, (3 << 7) | (ratio << 2) | (1 << 1) | 1);
2124 			dib0090_read_reg(state, 0x40);
2125 			ret = 50;
2126 		} else {
2127 			state->step /= 2;
2128 			dib0090_write_reg(state, 0x18, lo4 | state->captrim);
2129 
2130 			if (state->identity.in_soc)
2131 				ret = 25;
2132 		}
2133 		*tune_state = CT_TUNER_STEP_1;
2134 
2135 	} else if (*tune_state == CT_TUNER_STEP_1) {
2136 		if (state->identity.p1g && !force_soft_search) {
2137 			dib0090_write_reg(state, 0x40, 0x18c | (0 << 1) | 0);
2138 			dib0090_read_reg(state, 0x40);
2139 
2140 			state->fcaptrim = dib0090_read_reg(state, 0x18) & 0x7F;
2141 			dprintk("***Final Captrim= 0x%x\n", state->fcaptrim);
2142 			*tune_state = CT_TUNER_STEP_3;
2143 
2144 		} else {
2145 			/* MERGE for all krosus before P1G */
2146 			adc = dib0090_get_slow_adc_val(state);
2147 			dprintk("CAPTRIM=%d; ADC = %d (ADC) & %dmV\n", (u32) state->captrim, (u32) adc, (u32) (adc) * (u32) 1800 / (u32) 1024);
2148 
2149 			if (state->rest == 0 || state->identity.in_soc) {	/* Just for 8090P SOCS where auto captrim HW bug : TO CHECK IN ACI for SOCS !!! if 400 for 8090p SOC => tune issue !!! */
2150 				adc_target = 200;
2151 			} else
2152 				adc_target = 400;
2153 
2154 			if (adc >= adc_target) {
2155 				adc -= adc_target;
2156 				step_sign = -1;
2157 			} else {
2158 				adc = adc_target - adc;
2159 				step_sign = 1;
2160 			}
2161 
2162 			if (adc < state->adc_diff) {
2163 				dprintk("CAPTRIM=%d is closer to target (%d/%d)\n", (u32) state->captrim, (u32) adc, (u32) state->adc_diff);
2164 				state->adc_diff = adc;
2165 				state->fcaptrim = state->captrim;
2166 			}
2167 
2168 			state->captrim += step_sign * state->step;
2169 			if (state->step >= 1)
2170 				*tune_state = CT_TUNER_STEP_0;
2171 			else
2172 				*tune_state = CT_TUNER_STEP_2;
2173 
2174 			ret = 25;
2175 		}
2176 	} else if (*tune_state == CT_TUNER_STEP_2) {	/* this step is only used by krosus < P1G */
2177 		/*write the final cptrim config */
2178 		dib0090_write_reg(state, 0x18, lo4 | state->fcaptrim);
2179 
2180 		*tune_state = CT_TUNER_STEP_3;
2181 
2182 	} else if (*tune_state == CT_TUNER_STEP_3) {
2183 		state->calibrate &= ~CAPTRIM_CAL;
2184 		*tune_state = CT_TUNER_STEP_0;
2185 	}
2186 
2187 	return ret;
2188 }
2189 
2190 static int dib0090_get_temperature(struct dib0090_state *state, enum frontend_tune_state *tune_state)
2191 {
2192 	int ret = 15;
2193 	s16 val;
2194 
2195 	switch (*tune_state) {
2196 	case CT_TUNER_START:
2197 		state->wbdmux = dib0090_read_reg(state, 0x10);
2198 		dib0090_write_reg(state, 0x10, (state->wbdmux & ~(0xff << 3)) | (0x8 << 3));
2199 
2200 		state->bias = dib0090_read_reg(state, 0x13);
2201 		dib0090_write_reg(state, 0x13, state->bias | (0x3 << 8));
2202 
2203 		*tune_state = CT_TUNER_STEP_0;
2204 		/* wait for the WBDMUX to switch and for the ADC to sample */
2205 		break;
2206 
2207 	case CT_TUNER_STEP_0:
2208 		state->adc_diff = dib0090_get_slow_adc_val(state);
2209 		dib0090_write_reg(state, 0x13, (state->bias & ~(0x3 << 8)) | (0x2 << 8));
2210 		*tune_state = CT_TUNER_STEP_1;
2211 		break;
2212 
2213 	case CT_TUNER_STEP_1:
2214 		val = dib0090_get_slow_adc_val(state);
2215 		state->temperature = ((s16) ((val - state->adc_diff) * 180) >> 8) + 55;
2216 
2217 		dprintk("temperature: %d C\n", state->temperature - 30);
2218 
2219 		*tune_state = CT_TUNER_STEP_2;
2220 		break;
2221 
2222 	case CT_TUNER_STEP_2:
2223 		dib0090_write_reg(state, 0x13, state->bias);
2224 		dib0090_write_reg(state, 0x10, state->wbdmux);	/* write back original WBDMUX */
2225 
2226 		*tune_state = CT_TUNER_START;
2227 		state->calibrate &= ~TEMP_CAL;
2228 		if (state->config->analog_output == 0)
2229 			dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14));
2230 
2231 		break;
2232 
2233 	default:
2234 		ret = 0;
2235 		break;
2236 	}
2237 	return ret;
2238 }
2239 
2240 #define WBD     0x781		/* 1 1 1 1 0000 0 0 1 */
2241 static int dib0090_tune(struct dvb_frontend *fe)
2242 {
2243 	struct dib0090_state *state = fe->tuner_priv;
2244 	const struct dib0090_tuning *tune = state->current_tune_table_index;
2245 	const struct dib0090_pll *pll = state->current_pll_table_index;
2246 	enum frontend_tune_state *tune_state = &state->tune_state;
2247 
2248 	u16 lo5, lo6, Den, tmp;
2249 	u32 FBDiv, Rest, FREF, VCOF_kHz = 0;
2250 	int ret = 10;		/* 1ms is the default delay most of the time */
2251 	u8 c, i;
2252 
2253 	/************************* VCO ***************************/
2254 	/* Default values for FG                                 */
2255 	/* from these are needed :                               */
2256 	/* Cp,HFdiv,VCOband,SD,Num,Den,FB and REFDiv             */
2257 
2258 	/* in any case we first need to do a calibration if needed */
2259 	if (*tune_state == CT_TUNER_START) {
2260 		/* deactivate DataTX before some calibrations */
2261 		if (state->calibrate & (DC_CAL | TEMP_CAL | WBD_CAL))
2262 			dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) & ~(1 << 14));
2263 		else
2264 			/* Activate DataTX in case a calibration has been done before */
2265 			if (state->config->analog_output == 0)
2266 				dib0090_write_reg(state, 0x23, dib0090_read_reg(state, 0x23) | (1 << 14));
2267 	}
2268 
2269 	if (state->calibrate & DC_CAL)
2270 		return dib0090_dc_offset_calibration(state, tune_state);
2271 	else if (state->calibrate & WBD_CAL) {
2272 		if (state->current_rf == 0)
2273 			state->current_rf = state->fe->dtv_property_cache.frequency / 1000;
2274 		return dib0090_wbd_calibration(state, tune_state);
2275 	} else if (state->calibrate & TEMP_CAL)
2276 		return dib0090_get_temperature(state, tune_state);
2277 	else if (state->calibrate & CAPTRIM_CAL)
2278 		return dib0090_captrim_search(state, tune_state);
2279 
2280 	if (*tune_state == CT_TUNER_START) {
2281 		/* if soc and AGC pwm control, disengage mux to be able to R/W access to 0x01 register to set the right filter (cutoff_freq_select) during the tune sequence, otherwise, SOC SERPAR error when accessing to 0x01 */
2282 		if (state->config->use_pwm_agc && state->identity.in_soc) {
2283 			tmp = dib0090_read_reg(state, 0x39);
2284 			if ((tmp >> 10) & 0x1)
2285 				dib0090_write_reg(state, 0x39, tmp & ~(1 << 10));
2286 		}
2287 
2288 		state->current_band = (u8) BAND_OF_FREQUENCY(state->fe->dtv_property_cache.frequency / 1000);
2289 		state->rf_request =
2290 			state->fe->dtv_property_cache.frequency / 1000 + (state->current_band ==
2291 					BAND_UHF ? state->config->freq_offset_khz_uhf : state->config->
2292 					freq_offset_khz_vhf);
2293 
2294 		/* in ISDB-T 1seg we shift tuning frequency */
2295 		if ((state->fe->dtv_property_cache.delivery_system == SYS_ISDBT && state->fe->dtv_property_cache.isdbt_sb_mode == 1
2296 					&& state->fe->dtv_property_cache.isdbt_partial_reception == 0)) {
2297 			const struct dib0090_low_if_offset_table *LUT_offset = state->config->low_if;
2298 			u8 found_offset = 0;
2299 			u32 margin_khz = 100;
2300 
2301 			if (LUT_offset != NULL) {
2302 				while (LUT_offset->RF_freq != 0xffff) {
2303 					if (((state->rf_request > (LUT_offset->RF_freq - margin_khz))
2304 								&& (state->rf_request < (LUT_offset->RF_freq + margin_khz)))
2305 							&& LUT_offset->std == state->fe->dtv_property_cache.delivery_system) {
2306 						state->rf_request += LUT_offset->offset_khz;
2307 						found_offset = 1;
2308 						break;
2309 					}
2310 					LUT_offset++;
2311 				}
2312 			}
2313 
2314 			if (found_offset == 0)
2315 				state->rf_request += 400;
2316 		}
2317 		if (state->current_rf != state->rf_request || (state->current_standard != state->fe->dtv_property_cache.delivery_system)) {
2318 			state->tuner_is_tuned = 0;
2319 			state->current_rf = 0;
2320 			state->current_standard = 0;
2321 
2322 			tune = dib0090_tuning_table;
2323 			if (state->identity.p1g)
2324 				tune = dib0090_p1g_tuning_table;
2325 
2326 			tmp = (state->identity.version >> 5) & 0x7;
2327 
2328 			if (state->identity.in_soc) {
2329 				if (state->config->force_cband_input) {	/* Use the CBAND input for all band */
2330 					if (state->current_band & BAND_CBAND || state->current_band & BAND_FM || state->current_band & BAND_VHF
2331 							|| state->current_band & BAND_UHF) {
2332 						state->current_band = BAND_CBAND;
2333 						if (state->config->is_dib7090e)
2334 							tune = dib0090_tuning_table_cband_7090e_sensitivity;
2335 						else
2336 							tune = dib0090_tuning_table_cband_7090;
2337 					}
2338 				} else {	/* Use the CBAND input for all band under UHF */
2339 					if (state->current_band & BAND_CBAND || state->current_band & BAND_FM || state->current_band & BAND_VHF) {
2340 						state->current_band = BAND_CBAND;
2341 						if (state->config->is_dib7090e)
2342 							tune = dib0090_tuning_table_cband_7090e_sensitivity;
2343 						else
2344 							tune = dib0090_tuning_table_cband_7090;
2345 					}
2346 				}
2347 			} else
2348 			 if (tmp == 0x4 || tmp == 0x7) {
2349 				/* CBAND tuner version for VHF */
2350 				if (state->current_band == BAND_FM || state->current_band == BAND_CBAND || state->current_band == BAND_VHF) {
2351 					state->current_band = BAND_CBAND;	/* Force CBAND */
2352 
2353 					tune = dib0090_tuning_table_fm_vhf_on_cband;
2354 					if (state->identity.p1g)
2355 						tune = dib0090_p1g_tuning_table_fm_vhf_on_cband;
2356 				}
2357 			}
2358 
2359 			pll = dib0090_pll_table;
2360 			if (state->identity.p1g)
2361 				pll = dib0090_p1g_pll_table;
2362 
2363 			/* Look for the interval */
2364 			while (state->rf_request > tune->max_freq)
2365 				tune++;
2366 			while (state->rf_request > pll->max_freq)
2367 				pll++;
2368 
2369 			state->current_tune_table_index = tune;
2370 			state->current_pll_table_index = pll;
2371 
2372 			dib0090_write_reg(state, 0x0b, 0xb800 | (tune->switch_trim));
2373 
2374 			VCOF_kHz = (pll->hfdiv * state->rf_request) * 2;
2375 
2376 			FREF = state->config->io.clock_khz;
2377 			if (state->config->fref_clock_ratio != 0)
2378 				FREF /= state->config->fref_clock_ratio;
2379 
2380 			FBDiv = (VCOF_kHz / pll->topresc / FREF);
2381 			Rest = (VCOF_kHz / pll->topresc) - FBDiv * FREF;
2382 
2383 			if (Rest < LPF)
2384 				Rest = 0;
2385 			else if (Rest < 2 * LPF)
2386 				Rest = 2 * LPF;
2387 			else if (Rest > (FREF - LPF)) {
2388 				Rest = 0;
2389 				FBDiv += 1;
2390 			} else if (Rest > (FREF - 2 * LPF))
2391 				Rest = FREF - 2 * LPF;
2392 			Rest = (Rest * 6528) / (FREF / 10);
2393 			state->rest = Rest;
2394 
2395 			/* external loop filter, otherwise:
2396 			 * lo5 = (0 << 15) | (0 << 12) | (0 << 11) | (3 << 9) | (4 << 6) | (3 << 4) | 4;
2397 			 * lo6 = 0x0e34 */
2398 
2399 			if (Rest == 0) {
2400 				if (pll->vco_band)
2401 					lo5 = 0x049f;
2402 				else
2403 					lo5 = 0x041f;
2404 			} else {
2405 				if (pll->vco_band)
2406 					lo5 = 0x049e;
2407 				else if (state->config->analog_output)
2408 					lo5 = 0x041d;
2409 				else
2410 					lo5 = 0x041c;
2411 			}
2412 
2413 			if (state->identity.p1g) {	/* Bias is done automatically in P1G */
2414 				if (state->identity.in_soc) {
2415 					if (state->identity.version == SOC_8090_P1G_11R1)
2416 						lo5 = 0x46f;
2417 					else
2418 						lo5 = 0x42f;
2419 				} else
2420 					lo5 = 0x42c;
2421 			}
2422 
2423 			lo5 |= (pll->hfdiv_code << 11) | (pll->vco_band << 7);	/* bit 15 is the split to the slave, we do not do it here */
2424 
2425 			if (!state->config->io.pll_int_loop_filt) {
2426 				if (state->identity.in_soc)
2427 					lo6 = 0xff98;
2428 				else if (state->identity.p1g || (Rest == 0))
2429 					lo6 = 0xfff8;
2430 				else
2431 					lo6 = 0xff28;
2432 			} else
2433 				lo6 = (state->config->io.pll_int_loop_filt << 3);
2434 
2435 			Den = 1;
2436 
2437 			if (Rest > 0) {
2438 				lo6 |= (1 << 2) | 2;
2439 				Den = 255;
2440 			}
2441 			dib0090_write_reg(state, 0x15, (u16) FBDiv);
2442 			if (state->config->fref_clock_ratio != 0)
2443 				dib0090_write_reg(state, 0x16, (Den << 8) | state->config->fref_clock_ratio);
2444 			else
2445 				dib0090_write_reg(state, 0x16, (Den << 8) | 1);
2446 			dib0090_write_reg(state, 0x17, (u16) Rest);
2447 			dib0090_write_reg(state, 0x19, lo5);
2448 			dib0090_write_reg(state, 0x1c, lo6);
2449 
2450 			lo6 = tune->tuner_enable;
2451 			if (state->config->analog_output)
2452 				lo6 = (lo6 & 0xff9f) | 0x2;
2453 
2454 			dib0090_write_reg(state, 0x24, lo6 | EN_LO | state->config->use_pwm_agc * EN_CRYSTAL);
2455 
2456 		}
2457 
2458 		state->current_rf = state->rf_request;
2459 		state->current_standard = state->fe->dtv_property_cache.delivery_system;
2460 
2461 		ret = 20;
2462 		state->calibrate = CAPTRIM_CAL;	/* captrim serach now */
2463 	}
2464 
2465 	else if (*tune_state == CT_TUNER_STEP_0) {	/* Warning : because of captrim cal, if you change this step, change it also in _cal.c file because it is the step following captrim cal state machine */
2466 		const struct dib0090_wbd_slope *wbd = state->current_wbd_table;
2467 
2468 		while (state->current_rf / 1000 > wbd->max_freq)
2469 			wbd++;
2470 
2471 		dib0090_write_reg(state, 0x1e, 0x07ff);
2472 		dprintk("Final Captrim: %d\n", (u32) state->fcaptrim);
2473 		dprintk("HFDIV code: %d\n", (u32) pll->hfdiv_code);
2474 		dprintk("VCO = %d\n", (u32) pll->vco_band);
2475 		dprintk("VCOF in kHz: %d ((%d*%d) << 1))\n", (u32) ((pll->hfdiv * state->rf_request) * 2), (u32) pll->hfdiv, (u32) state->rf_request);
2476 		dprintk("REFDIV: %d, FREF: %d\n", (u32) 1, (u32) state->config->io.clock_khz);
2477 		dprintk("FBDIV: %d, Rest: %d\n", (u32) dib0090_read_reg(state, 0x15), (u32) dib0090_read_reg(state, 0x17));
2478 		dprintk("Num: %d, Den: %d, SD: %d\n", (u32) dib0090_read_reg(state, 0x17), (u32) (dib0090_read_reg(state, 0x16) >> 8),
2479 			(u32) dib0090_read_reg(state, 0x1c) & 0x3);
2480 
2481 #define WBD     0x781		/* 1 1 1 1 0000 0 0 1 */
2482 		c = 4;
2483 		i = 3;
2484 
2485 		if (wbd->wbd_gain != 0)
2486 			c = wbd->wbd_gain;
2487 
2488 		state->wbdmux = (c << 13) | (i << 11) | (WBD | (state->config->use_pwm_agc << 1));
2489 		dib0090_write_reg(state, 0x10, state->wbdmux);
2490 
2491 		if ((tune->tuner_enable == EN_CAB) && state->identity.p1g) {
2492 			dprintk("P1G : The cable band is selected and lna_tune = %d\n", tune->lna_tune);
2493 			dib0090_write_reg(state, 0x09, tune->lna_bias);
2494 			dib0090_write_reg(state, 0x0b, 0xb800 | (tune->lna_tune << 6) | (tune->switch_trim));
2495 		} else
2496 			dib0090_write_reg(state, 0x09, (tune->lna_tune << 5) | tune->lna_bias);
2497 
2498 		dib0090_write_reg(state, 0x0c, tune->v2i);
2499 		dib0090_write_reg(state, 0x0d, tune->mix);
2500 		dib0090_write_reg(state, 0x0e, tune->load);
2501 		*tune_state = CT_TUNER_STEP_1;
2502 
2503 	} else if (*tune_state == CT_TUNER_STEP_1) {
2504 		/* initialize the lt gain register */
2505 		state->rf_lt_def = 0x7c00;
2506 
2507 		dib0090_set_bandwidth(state);
2508 		state->tuner_is_tuned = 1;
2509 
2510 		state->calibrate |= WBD_CAL;
2511 		state->calibrate |= TEMP_CAL;
2512 		*tune_state = CT_TUNER_STOP;
2513 	} else
2514 		ret = FE_CALLBACK_TIME_NEVER;
2515 	return ret;
2516 }
2517 
2518 static void dib0090_release(struct dvb_frontend *fe)
2519 {
2520 	kfree(fe->tuner_priv);
2521 	fe->tuner_priv = NULL;
2522 }
2523 
2524 enum frontend_tune_state dib0090_get_tune_state(struct dvb_frontend *fe)
2525 {
2526 	struct dib0090_state *state = fe->tuner_priv;
2527 
2528 	return state->tune_state;
2529 }
2530 
2531 EXPORT_SYMBOL(dib0090_get_tune_state);
2532 
2533 int dib0090_set_tune_state(struct dvb_frontend *fe, enum frontend_tune_state tune_state)
2534 {
2535 	struct dib0090_state *state = fe->tuner_priv;
2536 
2537 	state->tune_state = tune_state;
2538 	return 0;
2539 }
2540 
2541 EXPORT_SYMBOL(dib0090_set_tune_state);
2542 
2543 static int dib0090_get_frequency(struct dvb_frontend *fe, u32 * frequency)
2544 {
2545 	struct dib0090_state *state = fe->tuner_priv;
2546 
2547 	*frequency = 1000 * state->current_rf;
2548 	return 0;
2549 }
2550 
2551 static int dib0090_set_params(struct dvb_frontend *fe)
2552 {
2553 	struct dib0090_state *state = fe->tuner_priv;
2554 	u32 ret;
2555 
2556 	state->tune_state = CT_TUNER_START;
2557 
2558 	do {
2559 		ret = dib0090_tune(fe);
2560 		if (ret == FE_CALLBACK_TIME_NEVER)
2561 			break;
2562 
2563 		/*
2564 		 * Despite dib0090_tune returns time at a 0.1 ms range,
2565 		 * the actual sleep time depends on CONFIG_HZ. The worse case
2566 		 * is when CONFIG_HZ=100. In such case, the minimum granularity
2567 		 * is 10ms. On some real field tests, the tuner sometimes don't
2568 		 * lock when this timer is lower than 10ms. So, enforce a 10ms
2569 		 * granularity and use usleep_range() instead of msleep().
2570 		 */
2571 		ret = 10 * (ret + 99)/100;
2572 		usleep_range(ret * 1000, (ret + 1) * 1000);
2573 	} while (state->tune_state != CT_TUNER_STOP);
2574 
2575 	return 0;
2576 }
2577 
2578 static const struct dvb_tuner_ops dib0090_ops = {
2579 	.info = {
2580 		 .name = "DiBcom DiB0090",
2581 		 .frequency_min = 45000000,
2582 		 .frequency_max = 860000000,
2583 		 .frequency_step = 1000,
2584 		 },
2585 	.release = dib0090_release,
2586 
2587 	.init = dib0090_wakeup,
2588 	.sleep = dib0090_sleep,
2589 	.set_params = dib0090_set_params,
2590 	.get_frequency = dib0090_get_frequency,
2591 };
2592 
2593 static const struct dvb_tuner_ops dib0090_fw_ops = {
2594 	.info = {
2595 		 .name = "DiBcom DiB0090",
2596 		 .frequency_min = 45000000,
2597 		 .frequency_max = 860000000,
2598 		 .frequency_step = 1000,
2599 		 },
2600 	.release = dib0090_release,
2601 
2602 	.init = NULL,
2603 	.sleep = NULL,
2604 	.set_params = NULL,
2605 	.get_frequency = NULL,
2606 };
2607 
2608 static const struct dib0090_wbd_slope dib0090_wbd_table_default[] = {
2609 	{470, 0, 250, 0, 100, 4},
2610 	{860, 51, 866, 21, 375, 4},
2611 	{1700, 0, 800, 0, 850, 4},
2612 	{2900, 0, 250, 0, 100, 6},
2613 	{0xFFFF, 0, 0, 0, 0, 0},
2614 };
2615 
2616 struct dvb_frontend *dib0090_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config)
2617 {
2618 	struct dib0090_state *st = kzalloc(sizeof(struct dib0090_state), GFP_KERNEL);
2619 	if (st == NULL)
2620 		return NULL;
2621 
2622 	st->config = config;
2623 	st->i2c = i2c;
2624 	st->fe = fe;
2625 	mutex_init(&st->i2c_buffer_lock);
2626 	fe->tuner_priv = st;
2627 
2628 	if (config->wbd == NULL)
2629 		st->current_wbd_table = dib0090_wbd_table_default;
2630 	else
2631 		st->current_wbd_table = config->wbd;
2632 
2633 	if (dib0090_reset(fe) != 0)
2634 		goto free_mem;
2635 
2636 	pr_info("DiB0090: successfully identified\n");
2637 	memcpy(&fe->ops.tuner_ops, &dib0090_ops, sizeof(struct dvb_tuner_ops));
2638 
2639 	return fe;
2640  free_mem:
2641 	kfree(st);
2642 	fe->tuner_priv = NULL;
2643 	return NULL;
2644 }
2645 
2646 EXPORT_SYMBOL(dib0090_register);
2647 
2648 struct dvb_frontend *dib0090_fw_register(struct dvb_frontend *fe, struct i2c_adapter *i2c, const struct dib0090_config *config)
2649 {
2650 	struct dib0090_fw_state *st = kzalloc(sizeof(struct dib0090_fw_state), GFP_KERNEL);
2651 	if (st == NULL)
2652 		return NULL;
2653 
2654 	st->config = config;
2655 	st->i2c = i2c;
2656 	st->fe = fe;
2657 	mutex_init(&st->i2c_buffer_lock);
2658 	fe->tuner_priv = st;
2659 
2660 	if (dib0090_fw_reset_digital(fe, st->config) != 0)
2661 		goto free_mem;
2662 
2663 	dprintk("DiB0090 FW: successfully identified\n");
2664 	memcpy(&fe->ops.tuner_ops, &dib0090_fw_ops, sizeof(struct dvb_tuner_ops));
2665 
2666 	return fe;
2667 free_mem:
2668 	kfree(st);
2669 	fe->tuner_priv = NULL;
2670 	return NULL;
2671 }
2672 EXPORT_SYMBOL(dib0090_fw_register);
2673 
2674 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2675 MODULE_AUTHOR("Olivier Grenie <olivier.grenie@parrot.com>");
2676 MODULE_DESCRIPTION("Driver for the DiBcom 0090 base-band RF Tuner");
2677 MODULE_LICENSE("GPL");
2678