1 /*
2  *  Driver for Conexant CX24113/CX24128 Tuner (Satellite)
3  *
4  *  Copyright (C) 2007-8 Patrick Boettcher <pb@linuxtv.org>
5  *
6  *  Developed for BBTI / Technisat
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *
17  *  GNU General Public License for more details.
18  */
19 
20 #include <linux/slab.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 
25 #include "dvb_frontend.h"
26 #include "cx24113.h"
27 
28 static int debug;
29 
30 #define cx_info(args...) do { printk(KERN_INFO "CX24113: " args); } while (0)
31 #define cx_err(args...)  do { printk(KERN_ERR  "CX24113: " args); } while (0)
32 
33 #define dprintk(args...) \
34 	do { \
35 		if (debug) { \
36 			printk(KERN_DEBUG "CX24113: %s: ", __func__); \
37 			printk(args); \
38 		} \
39 	} while (0)
40 
41 struct cx24113_state {
42 	struct i2c_adapter *i2c;
43 	const struct cx24113_config *config;
44 
45 #define REV_CX24113 0x23
46 	u8 rev;
47 	u8 ver;
48 
49 	u8 icp_mode:1;
50 
51 #define ICP_LEVEL1 0
52 #define ICP_LEVEL2 1
53 #define ICP_LEVEL3 2
54 #define ICP_LEVEL4 3
55 	u8 icp_man:2;
56 	u8 icp_auto_low:2;
57 	u8 icp_auto_mlow:2;
58 	u8 icp_auto_mhi:2;
59 	u8 icp_auto_hi:2;
60 	u8 icp_dig;
61 
62 #define LNA_MIN_GAIN 0
63 #define LNA_MID_GAIN 1
64 #define LNA_MAX_GAIN 2
65 	u8 lna_gain:2;
66 
67 	u8 acp_on:1;
68 
69 	u8 vco_mode:2;
70 	u8 vco_shift:1;
71 #define VCOBANDSEL_6 0x80
72 #define VCOBANDSEL_5 0x01
73 #define VCOBANDSEL_4 0x02
74 #define VCOBANDSEL_3 0x04
75 #define VCOBANDSEL_2 0x08
76 #define VCOBANDSEL_1 0x10
77 	u8 vco_band;
78 
79 #define VCODIV4 4
80 #define VCODIV2 2
81 	u8 vcodiv;
82 
83 	u8 bs_delay:4;
84 	u16 bs_freqcnt:13;
85 	u16 bs_rdiv;
86 	u8 prescaler_mode:1;
87 
88 	u8 rfvga_bias_ctrl;
89 
90 	s16 tuner_gain_thres;
91 	u8  gain_level;
92 
93 	u32 frequency;
94 
95 	u8 refdiv;
96 
97 	u8 Fwindow_enabled;
98 };
99 
100 static int cx24113_writereg(struct cx24113_state *state, int reg, int data)
101 {
102 	u8 buf[] = { reg, data };
103 	struct i2c_msg msg = { .addr = state->config->i2c_addr,
104 		.flags = 0, .buf = buf, .len = 2 };
105 	int err = i2c_transfer(state->i2c, &msg, 1);
106 	if (err != 1) {
107 		printk(KERN_DEBUG "%s: writereg error(err == %i, reg == 0x%02x, data == 0x%02x)\n",
108 		       __func__, err, reg, data);
109 		return err;
110 	}
111 
112 	return 0;
113 }
114 
115 static int cx24113_readreg(struct cx24113_state *state, u8 reg)
116 {
117 	int ret;
118 	u8 b;
119 	struct i2c_msg msg[] = {
120 		{ .addr = state->config->i2c_addr,
121 			.flags = 0, .buf = &reg, .len = 1 },
122 		{ .addr = state->config->i2c_addr,
123 			.flags = I2C_M_RD, .buf = &b, .len = 1 }
124 	};
125 
126 	ret = i2c_transfer(state->i2c, msg, 2);
127 
128 	if (ret != 2) {
129 		printk(KERN_DEBUG "%s: reg=0x%x (error=%d)\n",
130 			__func__, reg, ret);
131 		return ret;
132 	}
133 
134 	return b;
135 }
136 
137 static void cx24113_set_parameters(struct cx24113_state *state)
138 {
139 	u8 r;
140 
141 	r = cx24113_readreg(state, 0x10) & 0x82;
142 	r |= state->icp_mode;
143 	r |= state->icp_man << 4;
144 	r |= state->icp_dig << 2;
145 	r |= state->prescaler_mode << 5;
146 	cx24113_writereg(state, 0x10, r);
147 
148 	r = (state->icp_auto_low  << 0) | (state->icp_auto_mlow << 2)
149 		| (state->icp_auto_mhi << 4) | (state->icp_auto_hi << 6);
150 	cx24113_writereg(state, 0x11, r);
151 
152 	if (state->rev == REV_CX24113) {
153 		r = cx24113_readreg(state, 0x20) & 0xec;
154 		r |= state->lna_gain;
155 		r |= state->rfvga_bias_ctrl << 4;
156 		cx24113_writereg(state, 0x20, r);
157 	}
158 
159 	r = cx24113_readreg(state, 0x12) & 0x03;
160 	r |= state->acp_on << 2;
161 	r |= state->bs_delay << 4;
162 	cx24113_writereg(state, 0x12, r);
163 
164 	r = cx24113_readreg(state, 0x18) & 0x40;
165 	r |= state->vco_shift;
166 	if (state->vco_band == VCOBANDSEL_6)
167 		r |= (1 << 7);
168 	else
169 		r |= (state->vco_band << 1);
170 	cx24113_writereg(state, 0x18, r);
171 
172 	r  = cx24113_readreg(state, 0x14) & 0x20;
173 	r |= (state->vco_mode << 6) | ((state->bs_freqcnt >> 8) & 0x1f);
174 	cx24113_writereg(state, 0x14, r);
175 	cx24113_writereg(state, 0x15, (state->bs_freqcnt        & 0xff));
176 
177 	cx24113_writereg(state, 0x16, (state->bs_rdiv >> 4) & 0xff);
178 	r = (cx24113_readreg(state, 0x17) & 0x0f) |
179 		((state->bs_rdiv & 0x0f) << 4);
180 	cx24113_writereg(state, 0x17, r);
181 }
182 
183 #define VGA_0 0x00
184 #define VGA_1 0x04
185 #define VGA_2 0x02
186 #define VGA_3 0x06
187 #define VGA_4 0x01
188 #define VGA_5 0x05
189 #define VGA_6 0x03
190 #define VGA_7 0x07
191 
192 #define RFVGA_0 0x00
193 #define RFVGA_1 0x01
194 #define RFVGA_2 0x02
195 #define RFVGA_3 0x03
196 
197 static int cx24113_set_gain_settings(struct cx24113_state *state,
198 		s16 power_estimation)
199 {
200 	u8 ampout = cx24113_readreg(state, 0x1d) & 0xf0,
201 	   vga    = cx24113_readreg(state, 0x1f) & 0x3f,
202 	   rfvga  = cx24113_readreg(state, 0x20) & 0xf3;
203 	u8 gain_level = power_estimation >= state->tuner_gain_thres;
204 
205 	dprintk("power estimation: %d, thres: %d, gain_level: %d/%d\n",
206 			power_estimation, state->tuner_gain_thres,
207 			state->gain_level, gain_level);
208 
209 	if (gain_level == state->gain_level)
210 		return 0; /* nothing to be done */
211 
212 	ampout |= 0xf;
213 
214 	if (gain_level) {
215 		rfvga |= RFVGA_0 << 2;
216 		vga   |= (VGA_7 << 3) | VGA_7;
217 	} else {
218 		rfvga |= RFVGA_2 << 2;
219 		vga  |= (VGA_6 << 3) | VGA_2;
220 	}
221 	state->gain_level = gain_level;
222 
223 	cx24113_writereg(state, 0x1d, ampout);
224 	cx24113_writereg(state, 0x1f, vga);
225 	cx24113_writereg(state, 0x20, rfvga);
226 
227 	return 1; /* did something */
228 }
229 
230 static int cx24113_set_Fref(struct cx24113_state *state, u8 high)
231 {
232 	u8 xtal = cx24113_readreg(state, 0x02);
233 	if (state->rev == 0x43 && state->vcodiv == VCODIV4)
234 		high = 1;
235 
236 	xtal &= ~0x2;
237 	if (high)
238 		xtal |= high << 1;
239 	return cx24113_writereg(state, 0x02, xtal);
240 }
241 
242 static int cx24113_enable(struct cx24113_state *state, u8 enable)
243 {
244 	u8 r21 = (cx24113_readreg(state, 0x21) & 0xc0) | enable;
245 	if (state->rev == REV_CX24113)
246 		r21 |= (1 << 1);
247 	return cx24113_writereg(state, 0x21, r21);
248 }
249 
250 static int cx24113_set_bandwidth(struct cx24113_state *state, u32 bandwidth_khz)
251 {
252 	u8 r;
253 
254 	if (bandwidth_khz <= 19000)
255 		r = 0x03 << 6;
256 	else if (bandwidth_khz <= 25000)
257 		r = 0x02 << 6;
258 	else
259 		r = 0x01 << 6;
260 
261 	dprintk("bandwidth to be set: %d\n", bandwidth_khz);
262 	bandwidth_khz *= 10;
263 	bandwidth_khz -= 10000;
264 	bandwidth_khz /= 1000;
265 	bandwidth_khz += 5;
266 	bandwidth_khz /= 10;
267 
268 	dprintk("bandwidth: %d %d\n", r >> 6, bandwidth_khz);
269 
270 	r |= bandwidth_khz & 0x3f;
271 
272 	return cx24113_writereg(state, 0x1e, r);
273 }
274 
275 static int cx24113_set_clk_inversion(struct cx24113_state *state, u8 on)
276 {
277 	u8 r = (cx24113_readreg(state, 0x10) & 0x7f) | ((on & 0x1) << 7);
278 	return cx24113_writereg(state, 0x10, r);
279 }
280 
281 static int cx24113_get_status(struct dvb_frontend *fe, u32 *status)
282 {
283 	struct cx24113_state *state = fe->tuner_priv;
284 	u8 r = (cx24113_readreg(state, 0x10) & 0x02) >> 1;
285 	if (r)
286 		*status |= TUNER_STATUS_LOCKED;
287 	dprintk("PLL locked: %d\n", r);
288 	return 0;
289 }
290 
291 static u8 cx24113_set_ref_div(struct cx24113_state *state, u8 refdiv)
292 {
293 	if (state->rev == 0x43 && state->vcodiv == VCODIV4)
294 		refdiv = 2;
295 	return state->refdiv = refdiv;
296 }
297 
298 static void cx24113_calc_pll_nf(struct cx24113_state *state, u16 *n, s32 *f)
299 {
300 	s32 N;
301 	s64 F;
302 	u64 dividend;
303 	u8 R, r;
304 	u8 vcodiv;
305 	u8 factor;
306 	s32 freq_hz = state->frequency * 1000;
307 
308 	if (state->config->xtal_khz < 20000)
309 		factor = 1;
310 	else
311 		factor = 2;
312 
313 	if (state->rev == REV_CX24113) {
314 		if (state->frequency >= 1100000)
315 			vcodiv = VCODIV2;
316 		else
317 			vcodiv = VCODIV4;
318 	} else {
319 		if (state->frequency >= 1165000)
320 			vcodiv = VCODIV2;
321 		else
322 			vcodiv = VCODIV4;
323 	}
324 	state->vcodiv = vcodiv;
325 
326 	dprintk("calculating N/F for %dHz with vcodiv %d\n", freq_hz, vcodiv);
327 	R = 0;
328 	do {
329 		R = cx24113_set_ref_div(state, R + 1);
330 
331 		/* calculate tuner PLL settings: */
332 		N =  (freq_hz / 100 * vcodiv) * R;
333 		N /= (state->config->xtal_khz) * factor * 2;
334 		N += 5;     /* For round up. */
335 		N /= 10;
336 		N -= 32;
337 	} while (N < 6 && R < 3);
338 
339 	if (N < 6) {
340 		cx_err("strange frequency: N < 6\n");
341 		return;
342 	}
343 	F = freq_hz;
344 	F *= (u64) (R * vcodiv * 262144);
345 	dprintk("1 N: %d, F: %lld, R: %d\n", N, (long long)F, R);
346 	/* do_div needs an u64 as first argument */
347 	dividend = F;
348 	do_div(dividend, state->config->xtal_khz * 1000 * factor * 2);
349 	F = dividend;
350 	dprintk("2 N: %d, F: %lld, R: %d\n", N, (long long)F, R);
351 	F -= (N + 32) * 262144;
352 
353 	dprintk("3 N: %d, F: %lld, R: %d\n", N, (long long)F, R);
354 
355 	if (state->Fwindow_enabled) {
356 		if (F > (262144 / 2 - 1638))
357 			F = 262144 / 2 - 1638;
358 		if (F < (-262144 / 2 + 1638))
359 			F = -262144 / 2 + 1638;
360 		if ((F < 3277 && F > 0) || (F > -3277 && F < 0)) {
361 			F = 0;
362 			r = cx24113_readreg(state, 0x10);
363 			cx24113_writereg(state, 0x10, r | (1 << 6));
364 		}
365 	}
366 	dprintk("4 N: %d, F: %lld, R: %d\n", N, (long long)F, R);
367 
368 	*n = (u16) N;
369 	*f = (s32) F;
370 }
371 
372 
373 static void cx24113_set_nfr(struct cx24113_state *state, u16 n, s32 f, u8 r)
374 {
375 	u8 reg;
376 	cx24113_writereg(state, 0x19, (n >> 1) & 0xff);
377 
378 	reg = ((n & 0x1) << 7) | ((f >> 11) & 0x7f);
379 	cx24113_writereg(state, 0x1a, reg);
380 
381 	cx24113_writereg(state, 0x1b, (f >> 3) & 0xff);
382 
383 	reg = cx24113_readreg(state, 0x1c) & 0x1f;
384 	cx24113_writereg(state, 0x1c, reg | ((f & 0x7) << 5));
385 
386 	cx24113_set_Fref(state, r - 1);
387 }
388 
389 static int cx24113_set_frequency(struct cx24113_state *state, u32 frequency)
390 {
391 	u8 r = 1; /* or 2 */
392 	u16 n = 6;
393 	s32 f = 0;
394 
395 	r = cx24113_readreg(state, 0x14);
396 	cx24113_writereg(state, 0x14, r & 0x3f);
397 
398 	r = cx24113_readreg(state, 0x10);
399 	cx24113_writereg(state, 0x10, r & 0xbf);
400 
401 	state->frequency = frequency;
402 
403 	dprintk("tuning to frequency: %d\n", frequency);
404 
405 	cx24113_calc_pll_nf(state, &n, &f);
406 	cx24113_set_nfr(state, n, f, state->refdiv);
407 
408 	r = cx24113_readreg(state, 0x18) & 0xbf;
409 	if (state->vcodiv != VCODIV2)
410 		r |= 1 << 6;
411 	cx24113_writereg(state, 0x18, r);
412 
413 	/* The need for this sleep is not clear. But helps in some cases */
414 	msleep(5);
415 
416 	r = cx24113_readreg(state, 0x1c) & 0xef;
417 	cx24113_writereg(state, 0x1c, r | (1 << 4));
418 	return 0;
419 }
420 
421 static int cx24113_init(struct dvb_frontend *fe)
422 {
423 	struct cx24113_state *state = fe->tuner_priv;
424 	int ret;
425 
426 	state->tuner_gain_thres = -50;
427 	state->gain_level = 255; /* to force a gain-setting initialization */
428 	state->icp_mode = 0;
429 
430 	if (state->config->xtal_khz < 11000) {
431 		state->icp_auto_hi  = ICP_LEVEL4;
432 		state->icp_auto_mhi  = ICP_LEVEL4;
433 		state->icp_auto_mlow = ICP_LEVEL3;
434 		state->icp_auto_low = ICP_LEVEL3;
435 	} else {
436 		state->icp_auto_hi  = ICP_LEVEL4;
437 		state->icp_auto_mhi  = ICP_LEVEL4;
438 		state->icp_auto_mlow = ICP_LEVEL3;
439 		state->icp_auto_low = ICP_LEVEL2;
440 	}
441 
442 	state->icp_dig = ICP_LEVEL3;
443 	state->icp_man = ICP_LEVEL1;
444 	state->acp_on  = 1;
445 	state->vco_mode = 0;
446 	state->vco_shift = 0;
447 	state->vco_band = VCOBANDSEL_1;
448 	state->bs_delay = 8;
449 	state->bs_freqcnt = 0x0fff;
450 	state->bs_rdiv = 0x0fff;
451 	state->prescaler_mode = 0;
452 	state->lna_gain = LNA_MAX_GAIN;
453 	state->rfvga_bias_ctrl = 1;
454 	state->Fwindow_enabled = 1;
455 
456 	cx24113_set_Fref(state, 0);
457 	cx24113_enable(state, 0x3d);
458 	cx24113_set_parameters(state);
459 
460 	cx24113_set_gain_settings(state, -30);
461 
462 	cx24113_set_bandwidth(state, 18025);
463 	cx24113_set_clk_inversion(state, 1);
464 
465 	if (state->config->xtal_khz >= 40000)
466 		ret = cx24113_writereg(state, 0x02,
467 			(cx24113_readreg(state, 0x02) & 0xfb) | (1 << 2));
468 	else
469 		ret = cx24113_writereg(state, 0x02,
470 			(cx24113_readreg(state, 0x02) & 0xfb) | (0 << 2));
471 
472 	return ret;
473 }
474 
475 static int cx24113_set_params(struct dvb_frontend *fe)
476 {
477 	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
478 	struct cx24113_state *state = fe->tuner_priv;
479 	/* for a ROLL-OFF factor of 0.35, 0.2: 600, 0.25: 625 */
480 	u32 roll_off = 675;
481 	u32 bw;
482 
483 	bw  = ((c->symbol_rate/100) * roll_off) / 1000;
484 	bw += (10000000/100) + 5;
485 	bw /= 10;
486 	bw += 1000;
487 	cx24113_set_bandwidth(state, bw);
488 
489 	cx24113_set_frequency(state, c->frequency);
490 	msleep(5);
491 	return cx24113_get_status(fe, &bw);
492 }
493 
494 static s8 cx24113_agc_table[2][10] = {
495 	{-54, -41, -35, -30, -25, -21, -16, -10,  -6,  -2},
496 	{-39, -35, -30, -25, -19, -15, -11,  -5,   1,   9},
497 };
498 
499 void cx24113_agc_callback(struct dvb_frontend *fe)
500 {
501 	struct cx24113_state *state = fe->tuner_priv;
502 	s16 s, i;
503 	if (!fe->ops.read_signal_strength)
504 		return;
505 
506 	do {
507 		/* this only works with the current CX24123 implementation */
508 		fe->ops.read_signal_strength(fe, (u16 *) &s);
509 		s >>= 8;
510 		dprintk("signal strength: %d\n", s);
511 		for (i = 0; i < sizeof(cx24113_agc_table[0]); i++)
512 			if (cx24113_agc_table[state->gain_level][i] > s)
513 				break;
514 		s = -25 - i*5;
515 	} while (cx24113_set_gain_settings(state, s));
516 }
517 EXPORT_SYMBOL(cx24113_agc_callback);
518 
519 static int cx24113_get_frequency(struct dvb_frontend *fe, u32 *frequency)
520 {
521 	struct cx24113_state *state = fe->tuner_priv;
522 	*frequency = state->frequency;
523 	return 0;
524 }
525 
526 static void cx24113_release(struct dvb_frontend *fe)
527 {
528 	struct cx24113_state *state = fe->tuner_priv;
529 	dprintk("\n");
530 	fe->tuner_priv = NULL;
531 	kfree(state);
532 }
533 
534 static const struct dvb_tuner_ops cx24113_tuner_ops = {
535 	.info = {
536 		.name           = "Conexant CX24113",
537 		.frequency_min  = 950000,
538 		.frequency_max  = 2150000,
539 		.frequency_step = 125,
540 	},
541 
542 	.release       = cx24113_release,
543 
544 	.init          = cx24113_init,
545 
546 	.set_params    = cx24113_set_params,
547 	.get_frequency = cx24113_get_frequency,
548 	.get_status    = cx24113_get_status,
549 };
550 
551 struct dvb_frontend *cx24113_attach(struct dvb_frontend *fe,
552 		const struct cx24113_config *config, struct i2c_adapter *i2c)
553 {
554 	/* allocate memory for the internal state */
555 	struct cx24113_state *state =
556 		kzalloc(sizeof(struct cx24113_state), GFP_KERNEL);
557 	int rc;
558 	if (state == NULL) {
559 		cx_err("Unable to kzalloc\n");
560 		goto error;
561 	}
562 
563 	/* setup the state */
564 	state->config = config;
565 	state->i2c = i2c;
566 
567 	cx_info("trying to detect myself\n");
568 
569 	/* making a dummy read, because of some expected troubles
570 	 * after power on */
571 	cx24113_readreg(state, 0x00);
572 
573 	rc = cx24113_readreg(state, 0x00);
574 	if (rc < 0) {
575 		cx_info("CX24113 not found.\n");
576 		goto error;
577 	}
578 	state->rev = rc;
579 
580 	switch (rc) {
581 	case 0x43:
582 		cx_info("detected CX24113 variant\n");
583 		break;
584 	case REV_CX24113:
585 		cx_info("successfully detected\n");
586 		break;
587 	default:
588 		cx_err("unsupported device id: %x\n", state->rev);
589 		goto error;
590 	}
591 	state->ver = cx24113_readreg(state, 0x01);
592 	cx_info("version: %x\n", state->ver);
593 
594 	/* create dvb_frontend */
595 	memcpy(&fe->ops.tuner_ops, &cx24113_tuner_ops,
596 			sizeof(struct dvb_tuner_ops));
597 	fe->tuner_priv = state;
598 	return fe;
599 
600 error:
601 	kfree(state);
602 
603 	return NULL;
604 }
605 EXPORT_SYMBOL(cx24113_attach);
606 
607 module_param(debug, int, 0644);
608 MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
609 
610 MODULE_AUTHOR("Patrick Boettcher <pb@linuxtv.org>");
611 MODULE_DESCRIPTION("DVB Frontend module for Conexant CX24113/CX24128hardware");
612 MODULE_LICENSE("GPL");
613 
614