1/*
2	STB6100 Silicon Tuner
3	Copyright (C) Manu Abraham (abraham.manu@gmail.com)
4
5	Copyright (C) ST Microelectronics
6
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20*/
21
22#include <linux/init.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/slab.h>
26#include <linux/string.h>
27
28#include "dvb_frontend.h"
29#include "stb6100.h"
30
31static unsigned int verbose;
32module_param(verbose, int, 0644);
33
34/* Max transfer size done by I2C transfer functions */
35#define MAX_XFER_SIZE  64
36
37#define FE_ERROR		0
38#define FE_NOTICE		1
39#define FE_INFO			2
40#define FE_DEBUG		3
41
42#define dprintk(x, y, z, format, arg...) do {						\
43	if (z) {									\
44		if	((x > FE_ERROR) && (x > y))					\
45			printk(KERN_ERR "%s: " format "\n", __func__ , ##arg);		\
46		else if	((x > FE_NOTICE) && (x > y))					\
47			printk(KERN_NOTICE "%s: " format "\n", __func__ , ##arg);	\
48		else if ((x > FE_INFO) && (x > y))					\
49			printk(KERN_INFO "%s: " format "\n", __func__ , ##arg);		\
50		else if ((x > FE_DEBUG) && (x > y))					\
51			printk(KERN_DEBUG "%s: " format "\n", __func__ , ##arg);	\
52	} else {									\
53		if (x > y)								\
54			printk(format, ##arg);						\
55	}										\
56} while (0)
57
58struct stb6100_lkup {
59	u32 val_low;
60	u32 val_high;
61	u8   reg;
62};
63
64static int stb6100_release(struct dvb_frontend *fe);
65
66static const struct stb6100_lkup lkup[] = {
67	{       0,  950000, 0x0a },
68	{  950000, 1000000, 0x0a },
69	{ 1000000, 1075000, 0x0c },
70	{ 1075000, 1200000, 0x00 },
71	{ 1200000, 1300000, 0x01 },
72	{ 1300000, 1370000, 0x02 },
73	{ 1370000, 1470000, 0x04 },
74	{ 1470000, 1530000, 0x05 },
75	{ 1530000, 1650000, 0x06 },
76	{ 1650000, 1800000, 0x08 },
77	{ 1800000, 1950000, 0x0a },
78	{ 1950000, 2150000, 0x0c },
79	{ 2150000, 9999999, 0x0c },
80	{       0,       0, 0x00 }
81};
82
83/* Register names for easy debugging.	*/
84static const char *stb6100_regnames[] = {
85	[STB6100_LD]		= "LD",
86	[STB6100_VCO]		= "VCO",
87	[STB6100_NI]		= "NI",
88	[STB6100_NF_LSB]	= "NF",
89	[STB6100_K]		= "K",
90	[STB6100_G]		= "G",
91	[STB6100_F]		= "F",
92	[STB6100_DLB]		= "DLB",
93	[STB6100_TEST1]		= "TEST1",
94	[STB6100_FCCK]		= "FCCK",
95	[STB6100_LPEN]		= "LPEN",
96	[STB6100_TEST3]		= "TEST3",
97};
98
99/* Template for normalisation, i.e. setting unused or undocumented
100 * bits as required according to the documentation.
101 */
102struct stb6100_regmask {
103	u8 mask;
104	u8 set;
105};
106
107static const struct stb6100_regmask stb6100_template[] = {
108	[STB6100_LD]		= { 0xff, 0x00 },
109	[STB6100_VCO]		= { 0xff, 0x00 },
110	[STB6100_NI]		= { 0xff, 0x00 },
111	[STB6100_NF_LSB]	= { 0xff, 0x00 },
112	[STB6100_K]		= { 0xc7, 0x38 },
113	[STB6100_G]		= { 0xef, 0x10 },
114	[STB6100_F]		= { 0x1f, 0xc0 },
115	[STB6100_DLB]		= { 0x38, 0xc4 },
116	[STB6100_TEST1]		= { 0x00, 0x8f },
117	[STB6100_FCCK]		= { 0x40, 0x0d },
118	[STB6100_LPEN]		= { 0xf0, 0x0b },
119	[STB6100_TEST3]		= { 0x00, 0xde },
120};
121
122/*
123 * Currently unused. Some boards might need it in the future
124 */
125static inline void stb6100_normalise_regs(u8 regs[])
126{
127	int i;
128
129	for (i = 0; i < STB6100_NUMREGS; i++)
130		regs[i] = (regs[i] & stb6100_template[i].mask) | stb6100_template[i].set;
131}
132
133static int stb6100_read_regs(struct stb6100_state *state, u8 regs[])
134{
135	int rc;
136	struct i2c_msg msg = {
137		.addr	= state->config->tuner_address,
138		.flags	= I2C_M_RD,
139		.buf	= regs,
140		.len	= STB6100_NUMREGS
141	};
142
143	rc = i2c_transfer(state->i2c, &msg, 1);
144	if (unlikely(rc != 1)) {
145		dprintk(verbose, FE_ERROR, 1, "Read (0x%x) err, rc=[%d]",
146			state->config->tuner_address, rc);
147
148		return -EREMOTEIO;
149	}
150	if (unlikely(verbose > FE_DEBUG)) {
151		int i;
152
153		dprintk(verbose, FE_DEBUG, 1, "    Read from 0x%02x", state->config->tuner_address);
154		for (i = 0; i < STB6100_NUMREGS; i++)
155			dprintk(verbose, FE_DEBUG, 1, "        %s: 0x%02x", stb6100_regnames[i], regs[i]);
156	}
157	return 0;
158}
159
160static int stb6100_read_reg(struct stb6100_state *state, u8 reg)
161{
162	u8 regs[STB6100_NUMREGS];
163
164	struct i2c_msg msg = {
165		.addr	= state->config->tuner_address + reg,
166		.flags	= I2C_M_RD,
167		.buf	= regs,
168		.len	= 1
169	};
170
171	i2c_transfer(state->i2c, &msg, 1);
172
173	if (unlikely(reg >= STB6100_NUMREGS)) {
174		dprintk(verbose, FE_ERROR, 1, "Invalid register offset 0x%x", reg);
175		return -EINVAL;
176	}
177	if (unlikely(verbose > FE_DEBUG)) {
178		dprintk(verbose, FE_DEBUG, 1, "    Read from 0x%02x", state->config->tuner_address);
179		dprintk(verbose, FE_DEBUG, 1, "        %s: 0x%02x", stb6100_regnames[reg], regs[0]);
180	}
181
182	return (unsigned int)regs[0];
183}
184
185static int stb6100_write_reg_range(struct stb6100_state *state, u8 buf[], int start, int len)
186{
187	int rc;
188	u8 cmdbuf[MAX_XFER_SIZE];
189	struct i2c_msg msg = {
190		.addr	= state->config->tuner_address,
191		.flags	= 0,
192		.buf	= cmdbuf,
193		.len	= len + 1
194	};
195
196	if (1 + len > sizeof(cmdbuf)) {
197		printk(KERN_WARNING
198		       "%s: i2c wr: len=%d is too big!\n",
199		       KBUILD_MODNAME, len);
200		return -EINVAL;
201	}
202
203	if (unlikely(start < 1 || start + len > STB6100_NUMREGS)) {
204		dprintk(verbose, FE_ERROR, 1, "Invalid register range %d:%d",
205			start, len);
206		return -EINVAL;
207	}
208	memcpy(&cmdbuf[1], buf, len);
209	cmdbuf[0] = start;
210
211	if (unlikely(verbose > FE_DEBUG)) {
212		int i;
213
214		dprintk(verbose, FE_DEBUG, 1, "    Write @ 0x%02x: [%d:%d]", state->config->tuner_address, start, len);
215		for (i = 0; i < len; i++)
216			dprintk(verbose, FE_DEBUG, 1, "        %s: 0x%02x", stb6100_regnames[start + i], buf[i]);
217	}
218	rc = i2c_transfer(state->i2c, &msg, 1);
219	if (unlikely(rc != 1)) {
220		dprintk(verbose, FE_ERROR, 1, "(0x%x) write err [%d:%d], rc=[%d]",
221			(unsigned int)state->config->tuner_address, start, len,	rc);
222		return -EREMOTEIO;
223	}
224	return 0;
225}
226
227static int stb6100_write_reg(struct stb6100_state *state, u8 reg, u8 data)
228{
229	if (unlikely(reg >= STB6100_NUMREGS)) {
230		dprintk(verbose, FE_ERROR, 1, "Invalid register offset 0x%x", reg);
231		return -EREMOTEIO;
232	}
233	data = (data & stb6100_template[reg].mask) | stb6100_template[reg].set;
234	return stb6100_write_reg_range(state, &data, reg, 1);
235}
236
237
238static int stb6100_get_status(struct dvb_frontend *fe, u32 *status)
239{
240	int rc;
241	struct stb6100_state *state = fe->tuner_priv;
242
243	rc = stb6100_read_reg(state, STB6100_LD);
244	if (rc < 0) {
245		dprintk(verbose, FE_ERROR, 1, "%s failed", __func__);
246		return rc;
247	}
248	return (rc & STB6100_LD_LOCK) ? TUNER_STATUS_LOCKED : 0;
249}
250
251static int stb6100_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
252{
253	int rc;
254	u8 f;
255	struct stb6100_state *state = fe->tuner_priv;
256
257	rc = stb6100_read_reg(state, STB6100_F);
258	if (rc < 0)
259		return rc;
260	f = rc & STB6100_F_F;
261
262	state->status.bandwidth = (f + 5) * 2000;	/* x2 for ZIF	*/
263
264	*bandwidth = state->bandwidth = state->status.bandwidth * 1000;
265	dprintk(verbose, FE_DEBUG, 1, "bandwidth = %u Hz", state->bandwidth);
266	return 0;
267}
268
269static int stb6100_set_bandwidth(struct dvb_frontend *fe, u32 bandwidth)
270{
271	u32 tmp;
272	int rc;
273	struct stb6100_state *state = fe->tuner_priv;
274
275	dprintk(verbose, FE_DEBUG, 1, "set bandwidth to %u Hz", bandwidth);
276
277	bandwidth /= 2; /* ZIF */
278
279	if (bandwidth >= 36000000)	/* F[4:0] BW/2 max =31+5=36 mhz for F=31	*/
280		tmp = 31;
281	else if (bandwidth <= 5000000)	/* bw/2 min = 5Mhz for F=0			*/
282		tmp = 0;
283	else				/* if 5 < bw/2 < 36				*/
284		tmp = (bandwidth + 500000) / 1000000 - 5;
285
286	/* Turn on LPF bandwidth setting clock control,
287	 * set bandwidth, wait 10ms, turn off.
288	 */
289	rc = stb6100_write_reg(state, STB6100_FCCK, 0x0d | STB6100_FCCK_FCCK);
290	if (rc < 0)
291		return rc;
292	rc = stb6100_write_reg(state, STB6100_F, 0xc0 | tmp);
293	if (rc < 0)
294		return rc;
295
296	msleep(5);  /*  This is dangerous as another (related) thread may start */
297
298	rc = stb6100_write_reg(state, STB6100_FCCK, 0x0d);
299	if (rc < 0)
300		return rc;
301
302	msleep(10);  /*  This is dangerous as another (related) thread may start */
303
304	return 0;
305}
306
307static int stb6100_get_frequency(struct dvb_frontend *fe, u32 *frequency)
308{
309	int rc;
310	u32 nint, nfrac, fvco;
311	int psd2, odiv;
312	struct stb6100_state *state = fe->tuner_priv;
313	u8 regs[STB6100_NUMREGS];
314
315	rc = stb6100_read_regs(state, regs);
316	if (rc < 0)
317		return rc;
318
319	odiv = (regs[STB6100_VCO] & STB6100_VCO_ODIV) >> STB6100_VCO_ODIV_SHIFT;
320	psd2 = (regs[STB6100_K] & STB6100_K_PSD2) >> STB6100_K_PSD2_SHIFT;
321	nint = regs[STB6100_NI];
322	nfrac = ((regs[STB6100_K] & STB6100_K_NF_MSB) << 8) | regs[STB6100_NF_LSB];
323	fvco = (nfrac * state->reference >> (9 - psd2)) + (nint * state->reference << psd2);
324	*frequency = state->frequency = fvco >> (odiv + 1);
325
326	dprintk(verbose, FE_DEBUG, 1,
327		"frequency = %u kHz, odiv = %u, psd2 = %u, fxtal = %u kHz, fvco = %u kHz, N(I) = %u, N(F) = %u",
328		state->frequency, odiv, psd2, state->reference,	fvco, nint, nfrac);
329	return 0;
330}
331
332
333static int stb6100_set_frequency(struct dvb_frontend *fe, u32 frequency)
334{
335	int rc;
336	const struct stb6100_lkup *ptr;
337	struct stb6100_state *state = fe->tuner_priv;
338	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
339
340	u32 srate = 0, fvco, nint, nfrac;
341	u8 regs[STB6100_NUMREGS];
342	u8 g, psd2, odiv;
343
344	dprintk(verbose, FE_DEBUG, 1, "Version 2010-8-14 13:51");
345
346	if (fe->ops.get_frontend) {
347		dprintk(verbose, FE_DEBUG, 1, "Get frontend parameters");
348		fe->ops.get_frontend(fe);
349	}
350	srate = p->symbol_rate;
351
352	/* Set up tuner cleanly, LPF calibration on */
353	rc = stb6100_write_reg(state, STB6100_FCCK, 0x4d | STB6100_FCCK_FCCK);
354	if (rc < 0)
355		return rc;  /* allow LPF calibration */
356
357	/* PLL Loop disabled, bias on, VCO on, synth on */
358	regs[STB6100_LPEN] = 0xeb;
359	rc = stb6100_write_reg(state, STB6100_LPEN, regs[STB6100_LPEN]);
360	if (rc < 0)
361		return rc;
362
363	/* Program the registers with their data values */
364
365	/* VCO divide ratio (LO divide ratio, VCO prescaler enable).	*/
366	if (frequency <= 1075000)
367		odiv = 1;
368	else
369		odiv = 0;
370
371	/* VCO enabled, search clock off as per LL3.7, 3.4.1 */
372	regs[STB6100_VCO] = 0xe0 | (odiv << STB6100_VCO_ODIV_SHIFT);
373
374	/* OSM	*/
375	for (ptr = lkup;
376	     (ptr->val_high != 0) && !CHKRANGE(frequency, ptr->val_low, ptr->val_high);
377	     ptr++);
378
379	if (ptr->val_high == 0) {
380		printk(KERN_ERR "%s: frequency out of range: %u kHz\n", __func__, frequency);
381		return -EINVAL;
382	}
383	regs[STB6100_VCO] = (regs[STB6100_VCO] & ~STB6100_VCO_OSM) | ptr->reg;
384	rc = stb6100_write_reg(state, STB6100_VCO, regs[STB6100_VCO]);
385	if (rc < 0)
386		return rc;
387
388	if ((frequency > 1075000) && (frequency <= 1325000))
389		psd2 = 0;
390	else
391		psd2 = 1;
392	/* F(VCO) = F(LO) * (ODIV == 0 ? 2 : 4)			*/
393	fvco = frequency << (1 + odiv);
394	/* N(I) = floor(f(VCO) / (f(XTAL) * (PSD2 ? 2 : 1)))	*/
395	nint = fvco / (state->reference << psd2);
396	/* N(F) = round(f(VCO) / f(XTAL) * (PSD2 ? 2 : 1) - N(I)) * 2 ^ 9	*/
397	nfrac = DIV_ROUND_CLOSEST((fvco - (nint * state->reference << psd2))
398					 << (9 - psd2), state->reference);
399
400	/* NI */
401	regs[STB6100_NI] = nint;
402	rc = stb6100_write_reg(state, STB6100_NI, regs[STB6100_NI]);
403	if (rc < 0)
404		return rc;
405
406	/* NF */
407	regs[STB6100_NF_LSB] = nfrac;
408	rc = stb6100_write_reg(state, STB6100_NF_LSB, regs[STB6100_NF_LSB]);
409	if (rc < 0)
410		return rc;
411
412	/* K */
413	regs[STB6100_K] = (0x38 & ~STB6100_K_PSD2) | (psd2 << STB6100_K_PSD2_SHIFT);
414	regs[STB6100_K] = (regs[STB6100_K] & ~STB6100_K_NF_MSB) | ((nfrac >> 8) & STB6100_K_NF_MSB);
415	rc = stb6100_write_reg(state, STB6100_K, regs[STB6100_K]);
416	if (rc < 0)
417		return rc;
418
419	/* G Baseband gain. */
420	if (srate >= 15000000)
421		g = 9;  /*  +4 dB */
422	else if (srate >= 5000000)
423		g = 11; /*  +8 dB */
424	else
425		g = 14; /* +14 dB */
426
427	regs[STB6100_G] = (0x10 & ~STB6100_G_G) | g;
428	regs[STB6100_G] &= ~STB6100_G_GCT; /* mask GCT */
429	regs[STB6100_G] |= (1 << 5); /* 2Vp-p Mode */
430	rc = stb6100_write_reg(state, STB6100_G, regs[STB6100_G]);
431	if (rc < 0)
432		return rc;
433
434	/* F we don't write as it is set up in BW set */
435
436	/* DLB set DC servo loop BW to 160Hz (LLA 3.8 / 2.1) */
437	regs[STB6100_DLB] = 0xcc;
438	rc = stb6100_write_reg(state, STB6100_DLB, regs[STB6100_DLB]);
439	if (rc < 0)
440		return rc;
441
442	dprintk(verbose, FE_DEBUG, 1,
443		"frequency = %u, srate = %u, g = %u, odiv = %u, psd2 = %u, fxtal = %u, osm = %u, fvco = %u, N(I) = %u, N(F) = %u",
444		frequency, srate, (unsigned int)g, (unsigned int)odiv,
445		(unsigned int)psd2, state->reference,
446		ptr->reg, fvco, nint, nfrac);
447
448	/* Set up the test registers */
449	regs[STB6100_TEST1] = 0x8f;
450	rc = stb6100_write_reg(state, STB6100_TEST1, regs[STB6100_TEST1]);
451	if (rc < 0)
452		return rc;
453	regs[STB6100_TEST3] = 0xde;
454	rc = stb6100_write_reg(state, STB6100_TEST3, regs[STB6100_TEST3]);
455	if (rc < 0)
456		return rc;
457
458	/* Bring up tuner according to LLA 3.7 3.4.1, step 2 */
459	regs[STB6100_LPEN] = 0xfb; /* PLL Loop enabled, bias on, VCO on, synth on */
460	rc = stb6100_write_reg(state, STB6100_LPEN, regs[STB6100_LPEN]);
461	if (rc < 0)
462		return rc;
463
464	msleep(2);
465
466	/* Bring up tuner according to LLA 3.7 3.4.1, step 3 */
467	regs[STB6100_VCO] &= ~STB6100_VCO_OCK;		/* VCO fast search		*/
468	rc = stb6100_write_reg(state, STB6100_VCO, regs[STB6100_VCO]);
469	if (rc < 0)
470		return rc;
471
472	msleep(10);  /*  This is dangerous as another (related) thread may start */ /* wait for LO to lock */
473
474	regs[STB6100_VCO] &= ~STB6100_VCO_OSCH;		/* vco search disabled		*/
475	regs[STB6100_VCO] |= STB6100_VCO_OCK;		/* search clock off		*/
476	rc = stb6100_write_reg(state, STB6100_VCO, regs[STB6100_VCO]);
477	if (rc < 0)
478		return rc;
479
480	rc = stb6100_write_reg(state, STB6100_FCCK, 0x0d);
481	if (rc < 0)
482		return rc;  /* Stop LPF calibration */
483
484	msleep(10);  /*  This is dangerous as another (related) thread may start */
485		     /* wait for stabilisation, (should not be necessary)		*/
486	return 0;
487}
488
489static int stb6100_sleep(struct dvb_frontend *fe)
490{
491	/* TODO: power down	*/
492	return 0;
493}
494
495static int stb6100_init(struct dvb_frontend *fe)
496{
497	struct stb6100_state *state = fe->tuner_priv;
498	struct tuner_state *status = &state->status;
499
500	status->tunerstep	= 125000;
501	status->ifreq		= 0;
502	status->refclock	= 27000000;	/* Hz	*/
503	status->iqsense		= 1;
504	status->bandwidth	= 36000;	/* kHz	*/
505	state->bandwidth	= status->bandwidth * 1000;	/* Hz	*/
506	state->reference	= status->refclock / 1000;	/* kHz	*/
507
508	/* Set default bandwidth. Modified, PN 13-May-10	*/
509	return 0;
510}
511
512static int stb6100_get_state(struct dvb_frontend *fe,
513			     enum tuner_param param,
514			     struct tuner_state *state)
515{
516	switch (param) {
517	case DVBFE_TUNER_FREQUENCY:
518		stb6100_get_frequency(fe, &state->frequency);
519		break;
520	case DVBFE_TUNER_TUNERSTEP:
521		break;
522	case DVBFE_TUNER_IFFREQ:
523		break;
524	case DVBFE_TUNER_BANDWIDTH:
525		stb6100_get_bandwidth(fe, &state->bandwidth);
526		break;
527	case DVBFE_TUNER_REFCLOCK:
528		break;
529	default:
530		break;
531	}
532
533	return 0;
534}
535
536static int stb6100_set_state(struct dvb_frontend *fe,
537			     enum tuner_param param,
538			     struct tuner_state *state)
539{
540	struct stb6100_state *tstate = fe->tuner_priv;
541
542	switch (param) {
543	case DVBFE_TUNER_FREQUENCY:
544		stb6100_set_frequency(fe, state->frequency);
545		tstate->frequency = state->frequency;
546		break;
547	case DVBFE_TUNER_TUNERSTEP:
548		break;
549	case DVBFE_TUNER_IFFREQ:
550		break;
551	case DVBFE_TUNER_BANDWIDTH:
552		stb6100_set_bandwidth(fe, state->bandwidth);
553		tstate->bandwidth = state->bandwidth;
554		break;
555	case DVBFE_TUNER_REFCLOCK:
556		break;
557	default:
558		break;
559	}
560
561	return 0;
562}
563
564static struct dvb_tuner_ops stb6100_ops = {
565	.info = {
566		.name			= "STB6100 Silicon Tuner",
567		.frequency_min		= 950000,
568		.frequency_max		= 2150000,
569		.frequency_step		= 0,
570	},
571
572	.init		= stb6100_init,
573	.sleep          = stb6100_sleep,
574	.get_status	= stb6100_get_status,
575	.get_state	= stb6100_get_state,
576	.set_state	= stb6100_set_state,
577	.release	= stb6100_release
578};
579
580struct dvb_frontend *stb6100_attach(struct dvb_frontend *fe,
581				    const struct stb6100_config *config,
582				    struct i2c_adapter *i2c)
583{
584	struct stb6100_state *state = NULL;
585
586	state = kzalloc(sizeof (struct stb6100_state), GFP_KERNEL);
587	if (!state)
588		return NULL;
589
590	state->config		= config;
591	state->i2c		= i2c;
592	state->frontend		= fe;
593	state->reference	= config->refclock / 1000; /* kHz */
594	fe->tuner_priv		= state;
595	fe->ops.tuner_ops	= stb6100_ops;
596
597	printk("%s: Attaching STB6100 \n", __func__);
598	return fe;
599}
600
601static int stb6100_release(struct dvb_frontend *fe)
602{
603	struct stb6100_state *state = fe->tuner_priv;
604
605	fe->tuner_priv = NULL;
606	kfree(state);
607
608	return 0;
609}
610
611EXPORT_SYMBOL(stb6100_attach);
612MODULE_PARM_DESC(verbose, "Set Verbosity level");
613
614MODULE_AUTHOR("Manu Abraham");
615MODULE_DESCRIPTION("STB6100 Silicon tuner");
616MODULE_LICENSE("GPL");
617