768cf1c436c89a347eb968cc56898ebc6b3987d2
[rtl-433.git] / src / tuner_fc0012.c
1 /*
2  * Fitipower FC0012 tuner driver
3  *
4  * Copyright (C) 2012 Hans-Frieder Vogt <hfvogt@gmx.net>
5  *
6  * modified for use in librtlsdr
7  * Copyright (C) 2012 Steve Markgraf <steve@steve-m.de>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24 #include <stdint.h>
25 #include <stdio.h>
26
27 #include "rtlsdr_i2c.h"
28 #include "tuner_fc0012.h"
29
30 static int fc0012_writereg(void *dev, uint8_t reg, uint8_t val)
31 {
32         uint8_t data[2];
33         data[0] = reg;
34         data[1] = val;
35
36         if (rtlsdr_i2c_write_fn(dev, FC0012_I2C_ADDR, data, 2) < 0)
37                 return -1;
38
39         return 0;
40 }
41
42 static int fc0012_readreg(void *dev, uint8_t reg, uint8_t *val)
43 {
44         uint8_t data = reg;
45
46         if (rtlsdr_i2c_write_fn(dev, FC0012_I2C_ADDR, &data, 1) < 0)
47                 return -1;
48
49         if (rtlsdr_i2c_read_fn(dev, FC0012_I2C_ADDR, &data, 1) < 0)
50                 return -1;
51
52         *val = data;
53
54         return 0;
55 }
56
57 /* Incomplete list of register settings:
58  *
59  * Name                 Reg     Bits    Desc
60  * CHIP_ID              0x00    0-7     Chip ID (constant 0xA1)
61  * RF_A                 0x01    0-3     Number of count-to-9 cycles in RF
62  *                                      divider (suggested: 2..9)
63  * RF_M                 0x02    0-7     Total number of cycles (to-8 and to-9)
64  *                                      in RF divider
65  * RF_K_HIGH            0x03    0-6     Bits 8..14 of fractional divider
66  * RF_K_LOW             0x04    0-7     Bits 0..7 of fractional RF divider
67  * RF_OUTDIV_A          0x05    3-7     Power of two required?
68  * LNA_POWER_DOWN       0x06    0       Set to 1 to switch off low noise amp
69  * RF_OUTDIV_B          0x06    1       Set to select 3 instead of 2 for the
70  *                                      RF output divider
71  * VCO_SPEED            0x06    3       Select tuning range of VCO:
72  *                                       0 = Low range, (ca. 1.1 - 1.5GHz)
73  *                                       1 = High range (ca. 1.4 - 1.8GHz)
74  * BANDWIDTH            0x06    6-7     Set bandwidth. 6MHz = 0x80, 7MHz=0x40
75  *                                      8MHz=0x00
76  * XTAL_SPEED           0x07    5       Set to 1 for 28.8MHz Crystal input
77  *                                      or 0 for 36MHz
78  * <agc params>         0x08    0-7
79  * EN_CAL_RSSI          0x09    4       Enable calibrate RSSI
80  *                                      (Receive Signal Strength Indicator)
81  * LNA_FORCE            0x0d    0
82  * AGC_FORCE            0x0d    ?
83  * LNA_GAIN             0x13    3-4     Low noise amp gain
84  * LNA_COMPS            0x15    3       ?
85  * VCO_CALIB            0x0e    7       Set high then low to calibrate VCO
86  *                                       (fast lock?)
87  * VCO_VOLTAGE          0x0e    0-6     Read Control voltage of VCO
88  *                                       (big value -> low freq)
89  */
90
91 int fc0012_init(void *dev)
92 {
93         int ret = 0;
94         unsigned int i;
95         uint8_t reg[] = {
96                 0x00,   /* dummy reg. 0 */
97                 0x05,   /* reg. 0x01 */
98                 0x10,   /* reg. 0x02 */
99                 0x00,   /* reg. 0x03 */
100                 0x00,   /* reg. 0x04 */
101                 0x0f,   /* reg. 0x05: may also be 0x0a */
102                 0x00,   /* reg. 0x06: divider 2, VCO slow */
103                 0x00,   /* reg. 0x07: may also be 0x0f */
104                 0xff,   /* reg. 0x08: AGC Clock divide by 256, AGC gain 1/256,
105                            Loop Bw 1/8 */
106                 0x6e,   /* reg. 0x09: Disable LoopThrough, Enable LoopThrough: 0x6f */
107                 0xb8,   /* reg. 0x0a: Disable LO Test Buffer */
108                 0x82,   /* reg. 0x0b: Output Clock is same as clock frequency,
109                            may also be 0x83 */
110                 0xfc,   /* reg. 0x0c: depending on AGC Up-Down mode, may need 0xf8 */
111                 0x02,   /* reg. 0x0d: AGC Not Forcing & LNA Forcing, 0x02 for DVB-T */
112                 0x00,   /* reg. 0x0e */
113                 0x00,   /* reg. 0x0f */
114                 0x00,   /* reg. 0x10: may also be 0x0d */
115                 0x00,   /* reg. 0x11 */
116                 0x1f,   /* reg. 0x12: Set to maximum gain */
117                 0x08,   /* reg. 0x13: Set to Middle Gain: 0x08,
118                            Low Gain: 0x00, High Gain: 0x10, enable IX2: 0x80 */
119                 0x00,   /* reg. 0x14 */
120                 0x04,   /* reg. 0x15: Enable LNA COMPS */
121         };
122
123 #if 0
124         switch (rtlsdr_get_tuner_clock(dev)) {
125         case FC_XTAL_27_MHZ:
126         case FC_XTAL_28_8_MHZ:
127                 reg[0x07] |= 0x20;
128                 break;
129         case FC_XTAL_36_MHZ:
130         default:
131                 break;
132         }
133 #endif
134         reg[0x07] |= 0x20;
135
136 //      if (priv->dual_master)
137         reg[0x0c] |= 0x02;
138
139         for (i = 1; i < sizeof(reg); i++) {
140                 ret = fc0012_writereg(dev, i, reg[i]);
141                 if (ret)
142                         break;
143         }
144
145         return ret;
146 }
147
148 int fc0012_set_params(void *dev, uint32_t freq, uint32_t bandwidth)
149 {
150         int i, ret = 0;
151         uint8_t reg[7], am, pm, multi, tmp;
152         uint64_t f_vco;
153         uint32_t xtal_freq_div_2;
154         uint16_t xin, xdiv;
155         int vco_select = 0;
156
157         xtal_freq_div_2 = rtlsdr_get_tuner_clock(dev) / 2;
158
159         /* select frequency divider and the frequency of VCO */
160         if (freq < 37084000) {          /* freq * 96 < 3560000000 */
161                 multi = 96;
162                 reg[5] = 0x82;
163                 reg[6] = 0x00;
164         } else if (freq < 55625000) {   /* freq * 64 < 3560000000 */
165                 multi = 64;
166                 reg[5] = 0x82;
167                 reg[6] = 0x02;
168         } else if (freq < 74167000) {   /* freq * 48 < 3560000000 */
169                 multi = 48;
170                 reg[5] = 0x42;
171                 reg[6] = 0x00;
172         } else if (freq < 111250000) {  /* freq * 32 < 3560000000 */
173                 multi = 32;
174                 reg[5] = 0x42;
175                 reg[6] = 0x02;
176         } else if (freq < 148334000) {  /* freq * 24 < 3560000000 */
177                 multi = 24;
178                 reg[5] = 0x22;
179                 reg[6] = 0x00;
180         } else if (freq < 222500000) {  /* freq * 16 < 3560000000 */
181                 multi = 16;
182                 reg[5] = 0x22;
183                 reg[6] = 0x02;
184         } else if (freq < 296667000) {  /* freq * 12 < 3560000000 */
185                 multi = 12;
186                 reg[5] = 0x12;
187                 reg[6] = 0x00;
188         } else if (freq < 445000000) {  /* freq * 8 < 3560000000 */
189                 multi = 8;
190                 reg[5] = 0x12;
191                 reg[6] = 0x02;
192         } else if (freq < 593334000) {  /* freq * 6 < 3560000000 */
193                 multi = 6;
194                 reg[5] = 0x0a;
195                 reg[6] = 0x00;
196         } else {
197                 multi = 4;
198                 reg[5] = 0x0a;
199                 reg[6] = 0x02;
200         }
201
202         f_vco = freq * multi;
203
204         if (f_vco >= 3060000000U) {
205                 reg[6] |= 0x08;
206                 vco_select = 1;
207         }
208
209         /* From divided value (XDIV) determined the FA and FP value */
210         xdiv = (uint16_t)(f_vco / xtal_freq_div_2);
211         if ((f_vco - xdiv * xtal_freq_div_2) >= (xtal_freq_div_2 / 2))
212                 xdiv++;
213
214         pm = (uint8_t)(xdiv / 8);
215         am = (uint8_t)(xdiv - (8 * pm));
216
217         if (am < 2) {
218                 am += 8;
219                 pm--;
220         }
221
222         if (pm > 31) {
223                 reg[1] = am + (8 * (pm - 31));
224                 reg[2] = 31;
225         } else {
226                 reg[1] = am;
227                 reg[2] = pm;
228         }
229
230         if ((reg[1] > 15) || (reg[2] < 0x0b)) {
231                 fprintf(stderr, "[FC0012] no valid PLL combination "
232                                 "found for %u Hz!\n", freq);
233                 return -1;
234         }
235
236         /* fix clock out */
237         reg[6] |= 0x20;
238
239         /* From VCO frequency determines the XIN ( fractional part of Delta
240            Sigma PLL) and divided value (XDIV) */
241         xin = (uint16_t)((f_vco - (f_vco / xtal_freq_div_2) * xtal_freq_div_2) / 1000);
242         xin = (xin << 15) / (xtal_freq_div_2 / 1000);
243         if (xin >= 16384)
244                 xin += 32768;
245
246         reg[3] = xin >> 8;      /* xin with 9 bit resolution */
247         reg[4] = xin & 0xff;
248
249         reg[6] &= 0x3f; /* bits 6 and 7 describe the bandwidth */
250         switch (bandwidth) {
251         case 6000000:
252                 reg[6] |= 0x80;
253                 break;
254         case 7000000:
255                 reg[6] |= 0x40;
256                 break;
257         case 8000000:
258         default:
259                 break;
260         }
261
262         /* modified for Realtek demod */
263         reg[5] |= 0x07;
264
265         for (i = 1; i <= 6; i++) {
266                 ret = fc0012_writereg(dev, i, reg[i]);
267                 if (ret)
268                         goto exit;
269         }
270
271         /* VCO Calibration */
272         ret = fc0012_writereg(dev, 0x0e, 0x80);
273         if (!ret)
274                 ret = fc0012_writereg(dev, 0x0e, 0x00);
275
276         /* VCO Re-Calibration if needed */
277         if (!ret)
278                 ret = fc0012_writereg(dev, 0x0e, 0x00);
279
280         if (!ret) {
281 //              msleep(10);
282                 ret = fc0012_readreg(dev, 0x0e, &tmp);
283         }
284         if (ret)
285                 goto exit;
286
287         /* vco selection */
288         tmp &= 0x3f;
289
290         if (vco_select) {
291                 if (tmp > 0x3c) {
292                         reg[6] &= ~0x08;
293                         ret = fc0012_writereg(dev, 0x06, reg[6]);
294                         if (!ret)
295                                 ret = fc0012_writereg(dev, 0x0e, 0x80);
296                         if (!ret)
297                                 ret = fc0012_writereg(dev, 0x0e, 0x00);
298                 }
299         } else {
300                 if (tmp < 0x02) {
301                         reg[6] |= 0x08;
302                         ret = fc0012_writereg(dev, 0x06, reg[6]);
303                         if (!ret)
304                                 ret = fc0012_writereg(dev, 0x0e, 0x80);
305                         if (!ret)
306                                 ret = fc0012_writereg(dev, 0x0e, 0x00);
307                 }
308         }
309
310 exit:
311         return ret;
312 }
313
314 int fc0012_set_gain(void *dev, int gain)
315 {
316         int ret;
317         uint8_t tmp = 0;
318
319         ret = fc0012_readreg(dev, 0x13, &tmp);
320
321         /* mask bits off */
322         tmp &= 0xe0;
323
324         switch (gain) {
325         case -99:               /* -9.9 dB */
326                 tmp |= 0x02;
327                 break;
328         case -40:               /* -4 dB */
329                 break;
330         case 71:
331                 tmp |= 0x08;    /* 7.1 dB */
332                 break;
333         case 179:
334                 tmp |= 0x17;    /* 17.9 dB */
335                 break;
336         case 192:
337         default:
338                 tmp |= 0x10;    /* 19.2 dB */
339                 break;
340         }
341
342         ret = fc0012_writereg(dev, 0x13, tmp);
343
344         return ret;
345 }