3 Copyright (C) Manu Abraham (abraham.manu@gmail.com)
5 Copyright (C) ST Microelectronics
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.
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.
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.
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>
28 #include "dvb_frontend.h"
31 static unsigned int verbose
;
32 module_param(verbose
, int, 0644);
40 #define dprintk(x, y, z, format, arg...) do { \
42 if ((x > FE_ERROR) && (x > y)) \
43 printk(KERN_ERR "%s: " format "\n", __func__ , ##arg); \
44 else if ((x > FE_NOTICE) && (x > y)) \
45 printk(KERN_NOTICE "%s: " format "\n", __func__ , ##arg); \
46 else if ((x > FE_INFO) && (x > y)) \
47 printk(KERN_INFO "%s: " format "\n", __func__ , ##arg); \
48 else if ((x > FE_DEBUG) && (x > y)) \
49 printk(KERN_DEBUG "%s: " format "\n", __func__ , ##arg); \
52 printk(format, ##arg); \
62 static int stb6100_release(struct dvb_frontend
*fe
);
64 static const struct stb6100_lkup lkup
[] = {
66 { 950000, 1000000, 0x0a },
67 { 1000000, 1075000, 0x0c },
68 { 1075000, 1200000, 0x00 },
69 { 1200000, 1300000, 0x01 },
70 { 1300000, 1370000, 0x02 },
71 { 1370000, 1470000, 0x04 },
72 { 1470000, 1530000, 0x05 },
73 { 1530000, 1650000, 0x06 },
74 { 1650000, 1800000, 0x08 },
75 { 1800000, 1950000, 0x0a },
76 { 1950000, 2150000, 0x0c },
77 { 2150000, 9999999, 0x0c },
81 /* Register names for easy debugging. */
82 static const char *stb6100_regnames
[] = {
84 [STB6100_VCO
] = "VCO",
86 [STB6100_NF_LSB
] = "NF",
90 [STB6100_DLB
] = "DLB",
91 [STB6100_TEST1
] = "TEST1",
92 [STB6100_FCCK
] = "FCCK",
93 [STB6100_LPEN
] = "LPEN",
94 [STB6100_TEST3
] = "TEST3",
97 /* Template for normalisation, i.e. setting unused or undocumented
98 * bits as required according to the documentation.
100 struct stb6100_regmask
{
105 static const struct stb6100_regmask stb6100_template
[] = {
106 [STB6100_LD
] = { 0xff, 0x00 },
107 [STB6100_VCO
] = { 0xff, 0x00 },
108 [STB6100_NI
] = { 0xff, 0x00 },
109 [STB6100_NF_LSB
] = { 0xff, 0x00 },
110 [STB6100_K
] = { 0xc7, 0x38 },
111 [STB6100_G
] = { 0xef, 0x10 },
112 [STB6100_F
] = { 0x1f, 0xc0 },
113 [STB6100_DLB
] = { 0x38, 0xc4 },
114 [STB6100_TEST1
] = { 0x00, 0x8f },
115 [STB6100_FCCK
] = { 0x40, 0x0d },
116 [STB6100_LPEN
] = { 0xf0, 0x0b },
117 [STB6100_TEST3
] = { 0x00, 0xde },
120 static void stb6100_normalise_regs(u8 regs
[])
124 for (i
= 0; i
< STB6100_NUMREGS
; i
++)
125 regs
[i
] = (regs
[i
] & stb6100_template
[i
].mask
) | stb6100_template
[i
].set
;
128 static int stb6100_read_regs(struct stb6100_state
*state
, u8 regs
[])
131 struct i2c_msg msg
= {
132 .addr
= state
->config
->tuner_address
,
135 .len
= STB6100_NUMREGS
138 rc
= i2c_transfer(state
->i2c
, &msg
, 1);
139 if (unlikely(rc
!= 1)) {
140 dprintk(verbose
, FE_ERROR
, 1, "Read (0x%x) err, rc=[%d]",
141 state
->config
->tuner_address
, rc
);
145 if (unlikely(verbose
> FE_DEBUG
)) {
148 dprintk(verbose
, FE_DEBUG
, 1, " Read from 0x%02x", state
->config
->tuner_address
);
149 for (i
= 0; i
< STB6100_NUMREGS
; i
++)
150 dprintk(verbose
, FE_DEBUG
, 1, " %s: 0x%02x", stb6100_regnames
[i
], regs
[i
]);
155 static int stb6100_read_reg(struct stb6100_state
*state
, u8 reg
)
157 u8 regs
[STB6100_NUMREGS
];
160 if (unlikely(reg
>= STB6100_NUMREGS
)) {
161 dprintk(verbose
, FE_ERROR
, 1, "Invalid register offset 0x%x", reg
);
164 if ((rc
= stb6100_read_regs(state
, regs
)) < 0)
166 return (unsigned int)regs
[reg
];
169 static int stb6100_write_reg_range(struct stb6100_state
*state
, u8 buf
[], int start
, int len
)
173 struct i2c_msg msg
= {
174 .addr
= state
->config
->tuner_address
,
180 if (unlikely(start
< 1 || start
+ len
> STB6100_NUMREGS
)) {
181 dprintk(verbose
, FE_ERROR
, 1, "Invalid register range %d:%d",
185 memcpy(&cmdbuf
[1], buf
, len
);
188 if (unlikely(verbose
> FE_DEBUG
)) {
191 dprintk(verbose
, FE_DEBUG
, 1, " Write @ 0x%02x: [%d:%d]", state
->config
->tuner_address
, start
, len
);
192 for (i
= 0; i
< len
; i
++)
193 dprintk(verbose
, FE_DEBUG
, 1, " %s: 0x%02x", stb6100_regnames
[start
+ i
], buf
[i
]);
195 rc
= i2c_transfer(state
->i2c
, &msg
, 1);
196 if (unlikely(rc
!= 1)) {
197 dprintk(verbose
, FE_ERROR
, 1, "(0x%x) write err [%d:%d], rc=[%d]",
198 (unsigned int)state
->config
->tuner_address
, start
, len
, rc
);
204 static int stb6100_write_reg(struct stb6100_state
*state
, u8 reg
, u8 data
)
206 if (unlikely(reg
>= STB6100_NUMREGS
)) {
207 dprintk(verbose
, FE_ERROR
, 1, "Invalid register offset 0x%x", reg
);
210 data
= (data
& stb6100_template
[reg
].mask
) | stb6100_template
[reg
].set
;
211 return stb6100_write_reg_range(state
, &data
, reg
, 1);
214 static int stb6100_write_regs(struct stb6100_state
*state
, u8 regs
[])
216 stb6100_normalise_regs(regs
);
217 return stb6100_write_reg_range(state
, ®s
[1], 1, STB6100_NUMREGS
- 1);
220 static int stb6100_get_status(struct dvb_frontend
*fe
, u32
*status
)
223 struct stb6100_state
*state
= fe
->tuner_priv
;
225 if ((rc
= stb6100_read_reg(state
, STB6100_LD
)) < 0)
228 return (rc
& STB6100_LD_LOCK
) ? TUNER_STATUS_LOCKED
: 0;
231 static int stb6100_get_bandwidth(struct dvb_frontend
*fe
, u32
*bandwidth
)
235 struct stb6100_state
*state
= fe
->tuner_priv
;
237 if ((rc
= stb6100_read_reg(state
, STB6100_F
)) < 0)
239 f
= rc
& STB6100_F_F
;
241 state
->status
.bandwidth
= (f
+ 5) * 2000; /* x2 for ZIF */
243 *bandwidth
= state
->bandwidth
= state
->status
.bandwidth
* 1000;
244 dprintk(verbose
, FE_DEBUG
, 1, "bandwidth = %u Hz", state
->bandwidth
);
248 static int stb6100_set_bandwidth(struct dvb_frontend
*fe
, u32 bandwidth
)
252 struct stb6100_state
*state
= fe
->tuner_priv
;
254 dprintk(verbose
, FE_DEBUG
, 1, "set bandwidth to %u Hz", bandwidth
);
256 bandwidth
/= 2; /* ZIF */
258 if (bandwidth
>= 36000000) /* F[4:0] BW/2 max =31+5=36 mhz for F=31 */
260 else if (bandwidth
<= 5000000) /* bw/2 min = 5Mhz for F=0 */
262 else /* if 5 < bw/2 < 36 */
263 tmp
= (bandwidth
+ 500000) / 1000000 - 5;
265 /* Turn on LPF bandwidth setting clock control,
266 * set bandwidth, wait 10ms, turn off.
268 if ((rc
= stb6100_write_reg(state
, STB6100_FCCK
, 0x0d | STB6100_FCCK_FCCK
)) < 0)
270 if ((rc
= stb6100_write_reg(state
, STB6100_F
, 0xc0 | tmp
)) < 0)
273 if ((rc
= stb6100_write_reg(state
, STB6100_FCCK
, 0x0d)) < 0)
279 static int stb6100_get_frequency(struct dvb_frontend
*fe
, u32
*frequency
)
282 u32 nint
, nfrac
, fvco
;
284 struct stb6100_state
*state
= fe
->tuner_priv
;
285 u8 regs
[STB6100_NUMREGS
];
287 if ((rc
= stb6100_read_regs(state
, regs
)) < 0)
290 odiv
= (regs
[STB6100_VCO
] & STB6100_VCO_ODIV
) >> STB6100_VCO_ODIV_SHIFT
;
291 psd2
= (regs
[STB6100_K
] & STB6100_K_PSD2
) >> STB6100_K_PSD2_SHIFT
;
292 nint
= regs
[STB6100_NI
];
293 nfrac
= ((regs
[STB6100_K
] & STB6100_K_NF_MSB
) << 8) | regs
[STB6100_NF_LSB
];
294 fvco
= (nfrac
* state
->reference
>> (9 - psd2
)) + (nint
* state
->reference
<< psd2
);
295 *frequency
= state
->frequency
= fvco
>> (odiv
+ 1);
297 dprintk(verbose
, FE_DEBUG
, 1,
298 "frequency = %u kHz, odiv = %u, psd2 = %u, fxtal = %u kHz, fvco = %u kHz, N(I) = %u, N(F) = %u",
299 state
->frequency
, odiv
, psd2
, state
->reference
, fvco
, nint
, nfrac
);
304 static int stb6100_set_frequency(struct dvb_frontend
*fe
, u32 frequency
)
307 const struct stb6100_lkup
*ptr
;
308 struct stb6100_state
*state
= fe
->tuner_priv
;
309 struct dvb_frontend_parameters p
;
311 u32 srate
= 0, fvco
, nint
, nfrac
;
312 u8 regs
[STB6100_NUMREGS
];
315 if ((rc
= stb6100_read_regs(state
, regs
)) < 0)
318 if (fe
->ops
.get_frontend
) {
319 dprintk(verbose
, FE_DEBUG
, 1, "Get frontend parameters");
320 fe
->ops
.get_frontend(fe
, &p
);
322 srate
= p
.u
.qpsk
.symbol_rate
;
324 regs
[STB6100_DLB
] = 0xdc;
326 regs
[STB6100_LPEN
] &= ~STB6100_LPEN_LPEN
; /* PLL Loop disabled */
328 if ((rc
= stb6100_write_regs(state
, regs
)) < 0)
332 if (srate
>= 15000000)
334 else if (srate
>= 5000000)
339 regs
[STB6100_G
] = (regs
[STB6100_G
] & ~STB6100_G_G
) | g
;
340 regs
[STB6100_G
] &= ~STB6100_G_GCT
; /* mask GCT */
341 regs
[STB6100_G
] |= (1 << 5); /* 2Vp-p Mode */
343 /* VCO divide ratio (LO divide ratio, VCO prescaler enable). */
344 if (frequency
<= 1075000)
348 regs
[STB6100_VCO
] = (regs
[STB6100_VCO
] & ~STB6100_VCO_ODIV
) | (odiv
<< STB6100_VCO_ODIV_SHIFT
);
350 if ((frequency
> 1075000) && (frequency
<= 1325000))
354 regs
[STB6100_K
] = (regs
[STB6100_K
] & ~STB6100_K_PSD2
) | (psd2
<< STB6100_K_PSD2_SHIFT
);
358 (ptr
->val_high
!= 0) && !CHKRANGE(frequency
, ptr
->val_low
, ptr
->val_high
);
360 if (ptr
->val_high
== 0) {
361 printk(KERN_ERR
"%s: frequency out of range: %u kHz\n", __func__
, frequency
);
364 regs
[STB6100_VCO
] = (regs
[STB6100_VCO
] & ~STB6100_VCO_OSM
) | ptr
->reg
;
366 /* F(VCO) = F(LO) * (ODIV == 0 ? 2 : 4) */
367 fvco
= frequency
<< (1 + odiv
);
368 /* N(I) = floor(f(VCO) / (f(XTAL) * (PSD2 ? 2 : 1))) */
369 nint
= fvco
/ (state
->reference
<< psd2
);
370 /* N(F) = round(f(VCO) / f(XTAL) * (PSD2 ? 2 : 1) - N(I)) * 2 ^ 9 */
371 nfrac
= DIV_ROUND_CLOSEST((fvco
- (nint
* state
->reference
<< psd2
))
374 dprintk(verbose
, FE_DEBUG
, 1,
375 "frequency = %u, srate = %u, g = %u, odiv = %u, psd2 = %u, fxtal = %u, osm = %u, fvco = %u, N(I) = %u, N(F) = %u",
376 frequency
, srate
, (unsigned int)g
, (unsigned int)odiv
,
377 (unsigned int)psd2
, state
->reference
,
378 ptr
->reg
, fvco
, nint
, nfrac
);
379 regs
[STB6100_NI
] = nint
;
380 regs
[STB6100_NF_LSB
] = nfrac
;
381 regs
[STB6100_K
] = (regs
[STB6100_K
] & ~STB6100_K_NF_MSB
) | ((nfrac
>> 8) & STB6100_K_NF_MSB
);
382 regs
[STB6100_VCO
] |= STB6100_VCO_OSCH
; /* VCO search enabled */
383 regs
[STB6100_VCO
] |= STB6100_VCO_OCK
; /* VCO search clock off */
384 regs
[STB6100_FCCK
] |= STB6100_FCCK_FCCK
; /* LPF BW setting clock enabled */
385 regs
[STB6100_LPEN
] &= ~STB6100_LPEN_LPEN
; /* PLL loop disabled */
387 regs
[STB6100_LPEN
] |= STB6100_LPEN_SYNP
| STB6100_LPEN_OSCP
| STB6100_LPEN_BEN
;
390 if ((rc
= stb6100_write_regs(state
, regs
)) < 0)
394 regs
[STB6100_LPEN
] |= STB6100_LPEN_LPEN
; /* PLL loop enabled */
395 if ((rc
= stb6100_write_reg(state
, STB6100_LPEN
, regs
[STB6100_LPEN
])) < 0)
398 regs
[STB6100_VCO
] &= ~STB6100_VCO_OCK
; /* VCO fast search */
399 if ((rc
= stb6100_write_reg(state
, STB6100_VCO
, regs
[STB6100_VCO
])) < 0)
402 msleep(10); /* wait for LO to lock */
403 regs
[STB6100_VCO
] &= ~STB6100_VCO_OSCH
; /* vco search disabled */
404 regs
[STB6100_VCO
] |= STB6100_VCO_OCK
; /* search clock off */
405 if ((rc
= stb6100_write_reg(state
, STB6100_VCO
, regs
[STB6100_VCO
])) < 0)
407 regs
[STB6100_FCCK
] &= ~STB6100_FCCK_FCCK
; /* LPF BW clock disabled */
408 stb6100_normalise_regs(regs
);
409 if ((rc
= stb6100_write_reg_range(state
, ®s
[1], 1, STB6100_NUMREGS
- 3)) < 0)
417 static int stb6100_sleep(struct dvb_frontend
*fe
)
419 /* TODO: power down */
423 static int stb6100_init(struct dvb_frontend
*fe
)
425 struct stb6100_state
*state
= fe
->tuner_priv
;
426 struct tuner_state
*status
= &state
->status
;
428 status
->tunerstep
= 125000;
430 status
->refclock
= 27000000; /* Hz */
432 status
->bandwidth
= 36000; /* kHz */
433 state
->bandwidth
= status
->bandwidth
* 1000; /* Hz */
434 state
->reference
= status
->refclock
/ 1000; /* kHz */
436 /* Set default bandwidth. */
437 return stb6100_set_bandwidth(fe
, state
->bandwidth
);
440 static int stb6100_get_state(struct dvb_frontend
*fe
,
441 enum tuner_param param
,
442 struct tuner_state
*state
)
445 case DVBFE_TUNER_FREQUENCY
:
446 stb6100_get_frequency(fe
, &state
->frequency
);
448 case DVBFE_TUNER_TUNERSTEP
:
450 case DVBFE_TUNER_IFFREQ
:
452 case DVBFE_TUNER_BANDWIDTH
:
453 stb6100_get_bandwidth(fe
, &state
->bandwidth
);
455 case DVBFE_TUNER_REFCLOCK
:
464 static int stb6100_set_state(struct dvb_frontend
*fe
,
465 enum tuner_param param
,
466 struct tuner_state
*state
)
468 struct stb6100_state
*tstate
= fe
->tuner_priv
;
471 case DVBFE_TUNER_FREQUENCY
:
472 stb6100_set_frequency(fe
, state
->frequency
);
473 tstate
->frequency
= state
->frequency
;
475 case DVBFE_TUNER_TUNERSTEP
:
477 case DVBFE_TUNER_IFFREQ
:
479 case DVBFE_TUNER_BANDWIDTH
:
480 stb6100_set_bandwidth(fe
, state
->bandwidth
);
481 tstate
->bandwidth
= state
->bandwidth
;
483 case DVBFE_TUNER_REFCLOCK
:
492 static struct dvb_tuner_ops stb6100_ops
= {
494 .name
= "STB6100 Silicon Tuner",
495 .frequency_min
= 950000,
496 .frequency_max
= 2150000,
500 .init
= stb6100_init
,
501 .sleep
= stb6100_sleep
,
502 .get_status
= stb6100_get_status
,
503 .get_state
= stb6100_get_state
,
504 .set_state
= stb6100_set_state
,
505 .release
= stb6100_release
508 struct dvb_frontend
*stb6100_attach(struct dvb_frontend
*fe
,
509 struct stb6100_config
*config
,
510 struct i2c_adapter
*i2c
)
512 struct stb6100_state
*state
= NULL
;
514 state
= kzalloc(sizeof (struct stb6100_state
), GFP_KERNEL
);
518 state
->config
= config
;
520 state
->frontend
= fe
;
521 state
->reference
= config
->refclock
/ 1000; /* kHz */
522 fe
->tuner_priv
= state
;
523 fe
->ops
.tuner_ops
= stb6100_ops
;
525 printk("%s: Attaching STB6100 \n", __func__
);
533 static int stb6100_release(struct dvb_frontend
*fe
)
535 struct stb6100_state
*state
= fe
->tuner_priv
;
537 fe
->tuner_priv
= NULL
;
543 EXPORT_SYMBOL(stb6100_attach
);
544 MODULE_PARM_DESC(verbose
, "Set Verbosity level");
546 MODULE_AUTHOR("Manu Abraham");
547 MODULE_DESCRIPTION("STB6100 Silicon tuner");
548 MODULE_LICENSE("GPL");