Update the bktr driver to match the current state of FreeBSD-current,
[dragonfly.git] / sys / dev / video / bktr / bktr_tuner.c
1 /*
2  * 1. Redistributions of source code must retain the
3  * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. All advertising materials mentioning features or use of this software
15  *    must display the following acknowledgement:
16  *      This product includes software developed by Amancio Hasty and
17  *      Roger Hardiman
18  * 4. The name of the author may not be used to endorse or promote products
19  *    derived from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  * $FreeBSD: src/sys/dev/bktr/bktr_tuner.c,v 1.18 2005/01/23 07:13:09 julian Exp
34  * $DragonFly: src/sys/dev/video/bktr/bktr_tuner.c,v 1.7 2005/03/12 11:35:27 corecode Exp $
35  */
36
37
38 /*
39  * This is part of the Driver for Video Capture Cards (Frame grabbers)
40  * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
41  * chipset.
42  * Copyright Roger Hardiman and Amancio Hasty.
43  *
44  * bktr_tuner : This deals with controlling the tuner fitted to TV cards.
45  */
46
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
50 #include <sys/vnode.h>
51
52 #include <bus/pci/pcivar.h>
53
54 #include <machine/bus_memio.h>          /* for bus space */
55 #include <machine/bus.h>
56 #include <sys/bus.h>
57
58 #include <dev/video/meteor/ioctl_meteor.h>
59 #include <dev/video/bktr/ioctl_bt848.h> /* extensions to ioctl_meteor.h */
60 #include <dev/video/bktr/bktr_reg.h>
61 #include <dev/video/bktr/bktr_tuner.h>
62 #include <dev/video/bktr/bktr_card.h>
63 #include <dev/video/bktr/bktr_core.h>
64
65
66
67 #if defined( TUNER_AFC )
68 #define AFC_DELAY               10000   /* 10 millisend delay */
69 #define AFC_BITS                0x07
70 #define AFC_FREQ_MINUS_125      0x00
71 #define AFC_FREQ_MINUS_62       0x01
72 #define AFC_FREQ_CENTERED       0x02
73 #define AFC_FREQ_PLUS_62        0x03
74 #define AFC_FREQ_PLUS_125       0x04
75 #define AFC_MAX_STEP            (5 * FREQFACTOR) /* no more than 5 MHz */
76 #endif /* TUNER_AFC */
77
78   
79 #define TTYPE_XXX               0
80 #define TTYPE_NTSC              1
81 #define TTYPE_NTSC_J            2
82 #define TTYPE_PAL               3
83 #define TTYPE_PAL_M             4
84 #define TTYPE_PAL_N             5
85 #define TTYPE_SECAM             6
86   
87 #define TSA552x_CB_MSB          (0x80)
88 #define TSA552x_CB_CP           (1<<6)  /* set this for fast tuning */
89 #define TSA552x_CB_T2           (1<<5)  /* test mode - Normally set to 0 */
90 #define TSA552x_CB_T1           (1<<4)  /* test mode - Normally set to 0 */
91 #define TSA552x_CB_T0           (1<<3)  /* test mode - Normally set to 1 */
92 #define TSA552x_CB_RSA          (1<<2)  /* 0 for 31.25 khz, 1 for 62.5 kHz */
93 #define TSA552x_CB_RSB          (1<<1)  /* 0 for FM 50kHz steps, 1 = Use RSA*/
94 #define TSA552x_CB_OS           (1<<0)  /* Set to 0 for normal operation */
95
96 #define TSA552x_RADIO           (TSA552x_CB_MSB |       \
97                                  TSA552x_CB_T0)
98
99 /* raise the charge pump voltage for fast tuning */
100 #define TSA552x_FCONTROL        (TSA552x_CB_MSB |       \
101                                  TSA552x_CB_CP  |       \
102                                  TSA552x_CB_T0  |       \
103                                  TSA552x_CB_RSA |       \
104                                  TSA552x_CB_RSB)
105   
106 /* lower the charge pump voltage for better residual oscillator FM */
107 #define TSA552x_SCONTROL        (TSA552x_CB_MSB |       \
108                                  TSA552x_CB_T0  |       \
109                                  TSA552x_CB_RSA |       \
110                                  TSA552x_CB_RSB)
111   
112 /* The control value for the ALPS TSCH5 Tuner */
113 #define TSCH5_FCONTROL          0x82
114 #define TSCH5_RADIO             0x86
115   
116 /* The control value for the ALPS TSBH1 Tuner */
117 #define TSBH1_FCONTROL          0xce
118
119
120 static void mt2032_set_tv_freq(bktr_ptr_t bktr, unsigned int freq);
121
122
123 static const struct TUNER tuners[] = {
124 /* XXX FIXME: fill in the band-switch crosspoints */
125         /* NO_TUNER */
126         { "<no>",                               /* the 'name' */
127            TTYPE_XXX,                           /* input type */
128            { 0x00,                              /* control byte for Tuner PLL */
129              0x00,
130              0x00,
131              0x00 },
132            { 0x00, 0x00 },                      /* band-switch crosspoints */
133            { 0x00, 0x00, 0x00,0x00} },          /* the band-switch values */
134
135         /* TEMIC_NTSC */
136         { "Temic NTSC",                         /* the 'name' */
137            TTYPE_NTSC,                          /* input type */
138            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
139              TSA552x_SCONTROL,
140              TSA552x_SCONTROL,
141              0x00 },
142            { 0x00, 0x00},                       /* band-switch crosspoints */
143            { 0x02, 0x04, 0x01, 0x00 } },        /* the band-switch values */
144
145         /* TEMIC_PAL */
146         { "Temic PAL",                          /* the 'name' */
147            TTYPE_PAL,                           /* input type */
148            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
149              TSA552x_SCONTROL,
150              TSA552x_SCONTROL,
151              0x00 },
152            { 0x00, 0x00 },                      /* band-switch crosspoints */
153            { 0x02, 0x04, 0x01, 0x00 } },        /* the band-switch values */
154
155         /* TEMIC_SECAM */
156         { "Temic SECAM",                        /* the 'name' */
157            TTYPE_SECAM,                         /* input type */
158            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
159              TSA552x_SCONTROL,
160              TSA552x_SCONTROL,
161              0x00 },
162            { 0x00, 0x00 },                      /* band-switch crosspoints */
163            { 0x02, 0x04, 0x01,0x00 } },         /* the band-switch values */
164
165         /* PHILIPS_NTSC */
166         { "Philips NTSC",                       /* the 'name' */
167            TTYPE_NTSC,                          /* input type */
168            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
169              TSA552x_SCONTROL,
170              TSA552x_SCONTROL,
171              0x00 },
172            { 0x00, 0x00 },                      /* band-switch crosspoints */
173            { 0xa0, 0x90, 0x30, 0x00 } },        /* the band-switch values */
174
175         /* PHILIPS_PAL */
176         { "Philips PAL",                        /* the 'name' */
177            TTYPE_PAL,                           /* input type */
178            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
179              TSA552x_SCONTROL,
180              TSA552x_SCONTROL,
181              0x00 },
182            { 0x00, 0x00 },                      /* band-switch crosspoints */
183            { 0xa0, 0x90, 0x30, 0x00 } },        /* the band-switch values */
184
185         /* PHILIPS_SECAM */
186         { "Philips SECAM",                      /* the 'name' */
187            TTYPE_SECAM,                         /* input type */
188            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
189              TSA552x_SCONTROL,
190              TSA552x_SCONTROL,
191              0x00 },
192            { 0x00, 0x00 },                      /* band-switch crosspoints */
193            { 0xa7, 0x97, 0x37, 0x00 } },        /* the band-switch values */
194
195         /* TEMIC_PAL I */
196         { "Temic PAL I",                        /* the 'name' */
197            TTYPE_PAL,                           /* input type */
198            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
199              TSA552x_SCONTROL,
200              TSA552x_SCONTROL,
201              0x00 },
202            { 0x00, 0x00 },                      /* band-switch crosspoints */
203            { 0x02, 0x04, 0x01,0x00 } },         /* the band-switch values */
204
205         /* PHILIPS_PALI */
206         { "Philips PAL I",                      /* the 'name' */
207            TTYPE_PAL,                           /* input type */
208            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
209              TSA552x_SCONTROL,
210              TSA552x_SCONTROL,
211              0x00 },
212           { 0x00, 0x00 },                      /* band-switch crosspoints */
213           { 0xa0, 0x90, 0x30,0x00 } },         /* the band-switch values */
214
215        /* PHILIPS_FR1236_NTSC */
216        { "Philips FR1236 NTSC FM",             /* the 'name' */
217           TTYPE_NTSC,                          /* input type */
218           { TSA552x_FCONTROL,                   /* control byte for Tuner PLL */
219             TSA552x_FCONTROL,
220             TSA552x_FCONTROL,
221             TSA552x_RADIO  },
222           { 0x00, 0x00 },                       /* band-switch crosspoints */
223           { 0xa0, 0x90, 0x30,0xa4 } },          /* the band-switch values */
224
225         /* PHILIPS_FR1216_PAL */
226         { "Philips FR1216 PAL FM" ,             /* the 'name' */
227            TTYPE_PAL,                           /* input type */
228            { TSA552x_FCONTROL,                  /* control byte for Tuner PLL */
229              TSA552x_FCONTROL,
230              TSA552x_FCONTROL,
231              TSA552x_RADIO },
232            { 0x00, 0x00 },                      /* band-switch crosspoints */
233            { 0xa0, 0x90, 0x30, 0xa4 } },        /* the band-switch values */
234
235         /* PHILIPS_FR1236_SECAM */
236         { "Philips FR1236 SECAM FM",            /* the 'name' */
237            TTYPE_SECAM,                         /* input type */
238            { TSA552x_FCONTROL,                  /* control byte for Tuner PLL */
239              TSA552x_FCONTROL,
240              TSA552x_FCONTROL,
241              TSA552x_RADIO },
242            { 0x00, 0x00 },                      /* band-switch crosspoints */
243            { 0xa7, 0x97, 0x37, 0xa4 } },        /* the band-switch values */
244
245         /* ALPS TSCH5 NTSC */
246         { "ALPS TSCH5 NTSC FM",                 /* the 'name' */
247            TTYPE_NTSC,                          /* input type */
248            { TSCH5_FCONTROL,                    /* control byte for Tuner PLL */
249              TSCH5_FCONTROL,
250              TSCH5_FCONTROL,
251              TSCH5_RADIO },
252            { 0x00, 0x00 },                      /* band-switch crosspoints */
253            { 0x14, 0x12, 0x11, 0x04 } },        /* the band-switch values */
254
255         /* ALPS TSBH1 NTSC */
256         { "ALPS TSBH1 NTSC",                    /* the 'name' */
257            TTYPE_NTSC,                          /* input type */
258            { TSBH1_FCONTROL,                    /* control byte for Tuner PLL */
259              TSBH1_FCONTROL,
260              TSBH1_FCONTROL,
261              0x00 },
262            { 0x00, 0x00 },                      /* band-switch crosspoints */
263            { 0x01, 0x02, 0x08, 0x00 } },         /* the band-switch values */
264
265         /* MT2032 Microtune */
266         { "MT2032",                             /* the 'name' */
267            TTYPE_PAL,                   /* input type */
268            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
269              TSA552x_SCONTROL,
270              TSA552x_SCONTROL,
271              0x00 },
272            { 0x00, 0x00 },                      /* band-switch crosspoints */
273            { 0xa0, 0x90, 0x30, 0x00 } },        /* the band-switch values */
274 };
275
276
277 /* scaling factor for frequencies expressed as ints */
278 #define FREQFACTOR              16
279
280 /*
281  * Format:
282  *      entry 0:         MAX legal channel
283  *      entry 1:         IF frequency
284  *                       expressed as fi{mHz} * 16,
285  *                       eg 45.75mHz == 45.75 * 16 = 732
286  *      entry 2:         [place holder/future]
287  *      entry 3:         base of channel record 0
288  *      entry 3 + (x*3): base of channel record 'x'
289  *      entry LAST:      NULL channel entry marking end of records
290  *
291  * Record:
292  *      int 0:          base channel
293  *      int 1:          frequency of base channel,
294  *                       expressed as fb{mHz} * 16,
295  *      int 2:          offset frequency between channels,
296  *                       expressed as fo{mHz} * 16,
297  */
298
299 /*
300  * North American Broadcast Channels:
301  *
302  *  2:  55.25 mHz -  4:  67.25 mHz
303  *  5:  77.25 mHz -  6:  83.25 mHz
304  *  7: 175.25 mHz - 13: 211.25 mHz
305  * 14: 471.25 mHz - 83: 885.25 mHz
306  *
307  * IF freq: 45.75 mHz
308  */
309 #define OFFSET  6.00
310 static int nabcst[] = {
311         83,     (int)( 45.75 * FREQFACTOR),     0,
312         14,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
313          7,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
314          5,     (int)( 77.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
315          2,     (int)( 55.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
316          0
317 };
318 #undef OFFSET
319
320 /*
321  * North American Cable Channels, IRC:
322  *
323  *  2:  55.25 mHz -  4:  67.25 mHz
324  *  5:  77.25 mHz -  6:  83.25 mHz
325  *  7: 175.25 mHz - 13: 211.25 mHz
326  * 14: 121.25 mHz - 22: 169.25 mHz
327  * 23: 217.25 mHz - 94: 643.25 mHz
328  * 95:  91.25 mHz - 99: 115.25 mHz
329  *
330  * IF freq: 45.75 mHz
331  */
332 #define OFFSET  6.00
333 static int irccable[] = {
334         116,    (int)( 45.75 * FREQFACTOR),     0,
335         100,    (int)(649.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
336         95,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
337         23,     (int)(217.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
338         14,     (int)(121.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
339          7,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
340          5,     (int)( 77.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
341          2,     (int)( 55.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
342          0
343 };
344 #undef OFFSET
345
346 /*
347  * North American Cable Channels, HRC:
348  *
349  * 2:   54 mHz  - 4:    66 mHz
350  * 5:   78 mHz  - 6:    84 mHz
351  * 7:  174 mHz  - 13:  210 mHz
352  * 14: 120 mHz  - 22:  168 mHz
353  * 23: 216 mHz  - 94:  642 mHz
354  * 95:  90 mHz  - 99:  114 mHz
355  *
356  * IF freq: 45.75 mHz
357  */
358 #define OFFSET  6.00
359 static int hrccable[] = {
360         116,    (int)( 45.75 * FREQFACTOR),     0,
361         100,    (int)(648.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
362         95,     (int)( 90.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
363         23,     (int)(216.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
364         14,     (int)(120.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
365         7,      (int)(174.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
366         5,      (int)( 78.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
367         2,      (int)( 54.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
368         0
369 };
370 #undef OFFSET
371
372 /*
373  * Western European broadcast channels:
374  *
375  * (there are others that appear to vary between countries - rmt)
376  *
377  * here's the table Philips provides:
378  * caution, some of the offsets don't compute...
379  *
380  *  1    4525   700     N21
381  * 
382  *  2    4825   700     E2
383  *  3    5525   700     E3
384  *  4    6225   700     E4
385  * 
386  *  5   17525   700     E5
387  *  6   18225   700     E6
388  *  7   18925   700     E7
389  *  8   19625   700     E8
390  *  9   20325   700     E9
391  * 10   21025   700     E10
392  * 11   21725   700     E11
393  * 12   22425   700     E12
394  * 
395  * 13    5375   700     ITA
396  * 14    6225   700     ITB
397  * 
398  * 15    8225   700     ITC
399  * 
400  * 16   17525   700     ITD
401  * 17   18325   700     ITE
402  * 
403  * 18   19225   700     ITF
404  * 19   20125   700     ITG
405  * 20   21025   700     ITH
406  * 
407  * 21   47125   800     E21
408  * 22   47925   800     E22
409  * 23   48725   800     E23
410  * 24   49525   800     E24
411  * 25   50325   800     E25
412  * 26   51125   800     E26
413  * 27   51925   800     E27
414  * 28   52725   800     E28
415  * 29   53525   800     E29
416  * 30   54325   800     E30
417  * 31   55125   800     E31
418  * 32   55925   800     E32
419  * 33   56725   800     E33
420  * 34   57525   800     E34
421  * 35   58325   800     E35
422  * 36   59125   800     E36
423  * 37   59925   800     E37
424  * 38   60725   800     E38
425  * 39   61525   800     E39
426  * 40   62325   800     E40
427  * 41   63125   800     E41
428  * 42   63925   800     E42
429  * 43   64725   800     E43
430  * 44   65525   800     E44
431  * 45   66325   800     E45
432  * 46   67125   800     E46
433  * 47   67925   800     E47
434  * 48   68725   800     E48
435  * 49   69525   800     E49
436  * 50   70325   800     E50
437  * 51   71125   800     E51
438  * 52   71925   800     E52
439  * 53   72725   800     E53
440  * 54   73525   800     E54
441  * 55   74325   800     E55
442  * 56   75125   800     E56
443  * 57   75925   800     E57
444  * 58   76725   800     E58
445  * 59   77525   800     E59
446  * 60   78325   800     E60
447  * 61   79125   800     E61
448  * 62   79925   800     E62
449  * 63   80725   800     E63
450  * 64   81525   800     E64
451  * 65   82325   800     E65
452  * 66   83125   800     E66
453  * 67   83925   800     E67
454  * 68   84725   800     E68
455  * 69   85525   800     E69
456  * 
457  * 70    4575   800     IA
458  * 71    5375   800     IB
459  * 72    6175   800     IC
460  * 
461  * 74    6925   700     S01
462  * 75    7625   700     S02
463  * 76    8325   700     S03
464  * 
465  * 80   10525   700     S1
466  * 81   11225   700     S2
467  * 82   11925   700     S3
468  * 83   12625   700     S4
469  * 84   13325   700     S5
470  * 85   14025   700     S6
471  * 86   14725   700     S7
472  * 87   15425   700     S8
473  * 88   16125   700     S9
474  * 89   16825   700     S10
475  * 90   23125   700     S11
476  * 91   23825   700     S12
477  * 92   24525   700     S13
478  * 93   25225   700     S14
479  * 94   25925   700     S15
480  * 95   26625   700     S16
481  * 96   27325   700     S17
482  * 97   28025   700     S18
483  * 98   28725   700     S19
484  * 99   29425   700     S20
485  *
486  *
487  * Channels S21 - S41 are taken from
488  * http://gemma.apple.com:80/dev/technotes/tn/tn1012.html
489  *
490  * 100  30325   800     S21
491  * 101  31125   800     S22
492  * 102  31925   800     S23
493  * 103  32725   800     S24
494  * 104  33525   800     S25
495  * 105  34325   800     S26         
496  * 106  35125   800     S27         
497  * 107  35925   800     S28         
498  * 108  36725   800     S29         
499  * 109  37525   800     S30         
500  * 110  38325   800     S31         
501  * 111  39125   800     S32         
502  * 112  39925   800     S33         
503  * 113  40725   800     S34         
504  * 114  41525   800     S35         
505  * 115  42325   800     S36         
506  * 116  43125   800     S37         
507  * 117  43925   800     S38         
508  * 118  44725   800     S39         
509  * 119  45525   800     S40         
510  * 120  46325   800     S41
511  * 
512  * 121   3890   000     IFFREQ
513  * 
514  */
515 static int weurope[] = {
516        121,     (int)( 38.90 * FREQFACTOR),     0, 
517        100,     (int)(303.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR), 
518         90,     (int)(231.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
519         80,     (int)(105.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),  
520         74,     (int)( 69.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),  
521         21,     (int)(471.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
522         17,     (int)(183.25 * FREQFACTOR),     (int)(9.00 * FREQFACTOR),
523         16,     (int)(175.25 * FREQFACTOR),     (int)(9.00 * FREQFACTOR),
524         15,     (int)(82.25 * FREQFACTOR),      (int)(8.50 * FREQFACTOR),
525         13,     (int)(53.75 * FREQFACTOR),      (int)(8.50 * FREQFACTOR),
526          5,     (int)(175.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
527          2,     (int)(48.25 * FREQFACTOR),      (int)(7.00 * FREQFACTOR),
528          0
529 };
530
531 /*
532  * Japanese Broadcast Channels:
533  *
534  *  1:  91.25MHz -  3: 103.25MHz
535  *  4: 171.25MHz -  7: 189.25MHz
536  *  8: 193.25MHz - 12: 217.25MHz  (VHF)
537  * 13: 471.25MHz - 62: 765.25MHz  (UHF)
538  *
539  * IF freq: 45.75 mHz
540  *  OR
541  * IF freq: 58.75 mHz
542  */
543 #define OFFSET  6.00
544 #define IF_FREQ 45.75
545 static int jpnbcst[] = {
546         62,     (int)(IF_FREQ * FREQFACTOR),    0,
547         13,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
548          8,     (int)(193.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
549          4,     (int)(171.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
550          1,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
551          0
552 };
553 #undef IF_FREQ
554 #undef OFFSET
555
556 /*
557  * Japanese Cable Channels:
558  *
559  *  1:  91.25MHz -  3: 103.25MHz
560  *  4: 171.25MHz -  7: 189.25MHz
561  *  8: 193.25MHz - 12: 217.25MHz
562  * 13: 109.25MHz - 21: 157.25MHz
563  * 22: 165.25MHz
564  * 23: 223.25MHz - 63: 463.25MHz
565  *
566  * IF freq: 45.75 mHz
567  */
568 #define OFFSET  6.00
569 #define IF_FREQ 45.75
570 static int jpncable[] = {
571         63,     (int)(IF_FREQ * FREQFACTOR),    0,
572         23,     (int)(223.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
573         22,     (int)(165.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
574         13,     (int)(109.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
575          8,     (int)(193.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
576          4,     (int)(171.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
577          1,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
578          0
579 };
580 #undef IF_FREQ
581 #undef OFFSET
582
583 /*
584  * xUSSR Broadcast Channels:
585  *
586  *  1:  49.75MHz -  2:  59.25MHz
587  *  3:  77.25MHz -  5:  93.25MHz
588  *  6: 175.25MHz - 12: 223.25MHz
589  * 13-20 - not exist
590  * 21: 471.25MHz - 34: 575.25MHz
591  * 35: 583.25MHz - 69: 855.25MHz
592  *
593  * Cable channels
594  *
595  * 70: 111.25MHz - 77: 167.25MHz
596  * 78: 231.25MHz -107: 463.25MHz
597  *
598  * IF freq: 38.90 MHz
599  */
600 #define IF_FREQ 38.90
601 static int xussr[] = {
602       107,     (int)(IF_FREQ * FREQFACTOR),    0,
603        78,     (int)(231.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR), 
604        70,     (int)(111.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
605        35,     (int)(583.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR), 
606        21,     (int)(471.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
607         6,     (int)(175.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),  
608         3,     (int)( 77.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),  
609         1,     (int)( 49.75 * FREQFACTOR),     (int)(9.50 * FREQFACTOR),
610         0
611 };
612 #undef IF_FREQ
613
614 /*
615  * Australian broadcast channels
616  */
617 #define OFFSET  7.00
618 #define IF_FREQ 38.90 
619 static int australia[] = {
620        83,     (int)(IF_FREQ * FREQFACTOR),    0,
621        28,     (int)(527.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
622        10,     (int)(209.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
623         6,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
624         4,     (int)( 95.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
625         3,     (int)( 86.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
626         1,     (int)( 57.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
627         0
628 };
629 #undef OFFSET
630 #undef IF_FREQ
631
632 /* 
633  * France broadcast channels
634  */
635 #define OFFSET 8.00
636 #define IF_FREQ 38.90
637 static int france[] = {
638         69,     (int)(IF_FREQ * FREQFACTOR),     0,
639         21,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 21 -> 69 */
640          5,     (int)(176.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 5 -> 10 */
641          4,     (int)( 63.75 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 4    */
642          3,     (int)( 60.50 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 3    */
643          1,     (int)( 47.75 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 1  2 */
644          0
645 }; 
646 #undef OFFSET
647 #undef IF_FREQ
648
649 static struct {
650         int     *ptr;
651         char    name[BT848_MAX_CHNLSET_NAME_LEN];
652 } freqTable[] = {
653         {NULL,          ""},
654         {nabcst,        "nabcst"},
655         {irccable,      "cableirc"},
656         {hrccable,      "cablehrc"},
657         {weurope,       "weurope"},
658         {jpnbcst,       "jpnbcst"},
659         {jpncable,      "jpncable"},
660         {xussr,         "xussr"},
661         {australia,     "australia"},
662         {france,        "france"},
663  
664 };
665
666 #define TBL_CHNL        freqTable[ bktr->tuner.chnlset ].ptr[ x ]
667 #define TBL_BASE_FREQ   freqTable[ bktr->tuner.chnlset ].ptr[ x + 1 ]
668 #define TBL_OFFSET      freqTable[ bktr->tuner.chnlset ].ptr[ x + 2 ]
669 static int
670 frequency_lookup( bktr_ptr_t bktr, int channel )
671 {
672         int     x;
673
674         /* check for "> MAX channel" */
675         x = 0;
676         if ( channel > TBL_CHNL )
677                 return( -1 );
678
679         /* search the table for data */
680         for ( x = 3; TBL_CHNL; x += 3 ) {
681                 if ( channel >= TBL_CHNL ) {
682                         return( TBL_BASE_FREQ +
683                                  ((channel - TBL_CHNL) * TBL_OFFSET) );
684                 }
685         }
686
687         /* not found, must be below the MIN channel */
688         return( -1 );
689 }
690 #undef TBL_OFFSET
691 #undef TBL_BASE_FREQ
692 #undef TBL_CHNL
693
694
695 #define TBL_IF  freqTable[ bktr->tuner.chnlset ].ptr[ 1 ]
696
697
698 /* Initialise the tuner structures in the bktr_softc */
699 /* This is needed as the tuner details are no longer globally declared */
700
701 void    select_tuner( bktr_ptr_t bktr, int tuner_type ) {
702         if (tuner_type < Bt848_MAX_TUNER) {
703                 bktr->card.tuner = &tuners[ tuner_type ];
704         } else {
705                 bktr->card.tuner = NULL;
706         }
707 }
708
709 /*
710  * Tuner Notes:
711  * Programming the tuner properly is quite complicated.
712  * Here are some notes, based on a FM1246 data sheet for a PAL-I tuner.
713  * The tuner (front end) covers 45.75 Mhz - 855.25 Mhz and an FM band of
714  * 87.5 Mhz to 108.0 Mhz.
715  *
716  * RF and IF.  RF = radio frequencies, it is the transmitted signal.
717  *             IF is the Intermediate Frequency (the offset from the base
718  *             signal where the video, color,  audio and NICAM signals are.
719  *
720  * Eg, Picture at 38.9 Mhz, Colour at 34.47 MHz, sound at 32.9 MHz
721  * NICAM at 32.348 Mhz.
722  * Strangely enough, there is an IF (intermediate frequency) for
723  * FM Radio which is 10.7 Mhz.
724  *
725  * The tuner also works in Bands. Philips bands are
726  * FM radio band 87.50 to 108.00 MHz
727  * Low band 45.75 to 170.00 MHz
728  * Mid band 170.00 to 450.00 MHz
729  * High band 450.00 to 855.25 MHz
730  *
731  *
732  * Now we need to set the PLL on the tuner to the required freuqncy.
733  * It has a programmable divisor.
734  * For TV we want
735  *  N = 16 (freq RF(pc) + freq IF(pc))  pc is picture carrier and RF and IF
736  *  are in MHz.
737
738  * For RADIO we want a different equation.
739  *  freq IF is 10.70 MHz (so the data sheet tells me)
740  * N = (freq RF + freq IF) / step size
741  * The step size must be set to 50 khz (so the data sheet tells me)
742  * (note this is 50 kHz, the other things are in MHz)
743  * so we end up with N = 20x(freq RF + 10.7)
744  *
745  */
746
747 #define LOW_BAND 0
748 #define MID_BAND 1
749 #define HIGH_BAND 2
750 #define FM_RADIO_BAND 3
751
752
753 /* Check if these are correct for other than Philips PAL */
754 #define STATUSBIT_COLD   0x80
755 #define STATUSBIT_LOCK   0x40
756 #define STATUSBIT_TV     0x20
757 #define STATUSBIT_STEREO 0x10 /* valid if FM (aka not TV) */
758 #define STATUSBIT_ADC    0x07
759
760 /*
761  * set the frequency of the tuner
762  * If 'type' is TV_FREQUENCY, the frequency is freq MHz*16
763  * If 'type' is FM_RADIO_FREQUENCY, the frequency is freq MHz * 100 
764  * (note *16 gives is 4 bits of fraction, eg steps of nnn.0625)
765  *
766  */
767 int
768 tv_freq( bktr_ptr_t bktr, int frequency, int type )
769 {
770         const struct TUNER*     tuner;
771         u_char                  addr;
772         u_char                  control;
773         u_char                  band;
774         int                     N;
775         int                     band_select = 0;
776 #if defined( TEST_TUNER_AFC )
777         int                     oldFrequency, afcDelta;
778 #endif
779
780         tuner = bktr->card.tuner;
781         if ( tuner == NULL )
782                 return( -1 );
783
784         if (tuner == &tuners[TUNER_MT2032]) {
785                 mt2032_set_tv_freq(bktr, frequency);
786                 return 0;
787         }
788         if (type == TV_FREQUENCY) {
789                 /*
790                  * select the band based on frequency
791                  * XXX FIXME: get the cross-over points from the tuner struct
792                  */
793                 if ( frequency < (160 * FREQFACTOR  ) )
794                     band_select = LOW_BAND;
795                 else if ( frequency < (454 * FREQFACTOR ) )
796                     band_select = MID_BAND;
797                 else
798                     band_select = HIGH_BAND;
799
800 #if defined( TEST_TUNER_AFC )
801                 if ( bktr->tuner.afc )
802                         frequency -= 4;
803 #endif
804                 /*
805                  * N = 16 * { fRF(pc) + fIF(pc) }
806                  * or N = 16* fRF(pc) + 16*fIF(pc) }
807                  * where:
808                  *  pc is picture carrier, fRF & fIF are in MHz
809                  *
810                  * fortunatly, frequency is passed in as MHz * 16
811                  * and the TBL_IF frequency is also stored in MHz * 16
812                  */
813                 N = frequency + TBL_IF;
814
815                 /* set the address of the PLL */
816                 addr    = bktr->card.tuner_pllAddr;
817                 control = tuner->pllControl[ band_select ];
818                 band    = tuner->bandAddrs[ band_select ];
819
820                 if(!(band && control))          /* Don't try to set un- */
821                   return(-1);                   /* supported modes.     */
822
823                 if ( frequency > bktr->tuner.frequency ) {
824                         i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
825                         i2cWrite( bktr, addr, control, band );
826                 }
827                 else {
828                         i2cWrite( bktr, addr, control, band );
829                         i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
830                 }
831
832 #if defined( TUNER_AFC )
833                 if ( bktr->tuner.afc == TRUE ) {
834 #if defined( TEST_TUNER_AFC )
835                         oldFrequency = frequency;
836 #endif
837                         if ( (N = do_afc( bktr, addr, N )) < 0 ) {
838                             /* AFC failed, restore requested frequency */
839                             N = frequency + TBL_IF;
840 #if defined( TEST_TUNER_AFC )
841                             printf("%s: do_afc: failed to lock\n",
842                                    bktr_name(bktr));
843 #endif
844                             i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
845                         }
846                         else
847                             frequency = N - TBL_IF;
848 #if defined( TEST_TUNER_AFC )
849  printf("%s: do_afc: returned freq %d (%d %% %d)\n", bktr_name(bktr), frequency, frequency / 16, frequency % 16);
850                             afcDelta = frequency - oldFrequency;
851  printf("%s: changed by: %d clicks (%d mod %d)\n", bktr_name(bktr), afcDelta, afcDelta / 16, afcDelta % 16);
852 #endif
853                         }
854 #endif /* TUNER_AFC */
855
856                 bktr->tuner.frequency = frequency;
857         }
858
859         if ( type == FM_RADIO_FREQUENCY ) {
860                 band_select = FM_RADIO_BAND;
861
862                 /*
863                  * N = { fRF(pc) + fIF(pc) }/step_size
864                  * The step size is 50kHz for FM radio.
865                  * (eg after 102.35MHz comes 102.40 MHz)
866                  * fIF is 10.7 MHz (as detailed in the specs)
867                  *
868                  * frequency is passed in as MHz * 100
869                  *
870                  * So, we have N = (frequency/100 + 10.70)  /(50/1000)
871                  */
872                 N = (frequency + 1070)/5;
873
874                 /* set the address of the PLL */
875                 addr    = bktr->card.tuner_pllAddr;
876                 control = tuner->pllControl[ band_select ];
877                 band    = tuner->bandAddrs[ band_select ];
878
879                 if(!(band && control))          /* Don't try to set un- */
880                   return(-1);                   /* supported modes.     */
881           
882                 band |= bktr->tuner.radio_mode; /* tuner.radio_mode is set in
883                                                  * the ioctls RADIO_SETMODE
884                                                  * and RADIO_GETMODE */
885
886                 i2cWrite( bktr, addr, control, band );
887                 i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
888
889                 bktr->tuner.frequency = (N * 5) - 1070;
890
891
892         }
893  
894
895         return( 0 );
896 }
897
898
899
900 #if defined( TUNER_AFC )
901 /*
902  * 
903  */
904 int
905 do_afc( bktr_ptr_t bktr, int addr, int frequency )
906 {
907         int step;
908         int status;
909         int origFrequency;
910
911         origFrequency = frequency;
912
913         /* wait for first setting to take effect */
914         tsleep( BKTR_SLEEP, 0, "tuning", hz/8 );
915
916         if ( (status = i2cRead( bktr, addr + 1 )) < 0 )
917                 return( -1 );
918
919 #if defined( TEST_TUNER_AFC )
920  printf( "%s: Original freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
921 #endif
922         for ( step = 0; step < AFC_MAX_STEP; ++step ) {
923                 if ( (status = i2cRead( bktr, addr + 1 )) < 0 )
924                         goto fubar;
925                 if ( !(status & 0x40) ) {
926 #if defined( TEST_TUNER_AFC )
927  printf( "%s: no lock!\n", bktr_name(bktr) );
928 #endif
929                         goto fubar;
930                 }
931
932                 switch( status & AFC_BITS ) {
933                 case AFC_FREQ_CENTERED:
934 #if defined( TEST_TUNER_AFC )
935  printf( "%s: Centered, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
936 #endif
937                         return( frequency );
938
939                 case AFC_FREQ_MINUS_125:
940                 case AFC_FREQ_MINUS_62:
941 #if defined( TEST_TUNER_AFC )
942  printf( "%s: Low, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
943 #endif
944                         --frequency;
945                         break;
946
947                 case AFC_FREQ_PLUS_62:
948                 case AFC_FREQ_PLUS_125:
949 #if defined( TEST_TUNER_AFC )
950  printf( "%s: Hi, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
951 #endif
952                         ++frequency;
953                         break;
954                 }
955
956                 i2cWrite( bktr, addr,
957                           (frequency>>8) & 0x7f, frequency & 0xff );
958                 DELAY( AFC_DELAY );
959         }
960
961  fubar:
962         i2cWrite( bktr, addr,
963                   (origFrequency>>8) & 0x7f, origFrequency & 0xff );
964
965         return( -1 );
966 }
967 #endif /* TUNER_AFC */
968 #undef TBL_IF
969
970
971 /*
972  * Get the Tuner status and signal strength
973  */
974 int     get_tuner_status( bktr_ptr_t bktr ) {
975         if (bktr->card.tuner == &tuners[TUNER_MT2032])
976                 return 0;
977         return i2cRead( bktr, bktr->card.tuner_pllAddr + 1 );
978 }
979
980 /*
981  * set the channel of the tuner
982  */
983 int
984 tv_channel( bktr_ptr_t bktr, int channel )
985 {
986         int frequency;
987
988         /* calculate the frequency according to tuner type */
989         if ( (frequency = frequency_lookup( bktr, channel )) < 0 )
990                 return( -1 );
991
992         /* set the new frequency */
993         if ( tv_freq( bktr, frequency, TV_FREQUENCY ) < 0 )
994                 return( -1 );
995
996         /* OK to update records */
997         return( (bktr->tuner.channel = channel) );
998 }
999
1000 /*
1001  * get channelset name
1002  */
1003 int
1004 tuner_getchnlset(struct bktr_chnlset *chnlset)
1005 {
1006        if (( chnlset->index < CHNLSET_MIN ) ||
1007                ( chnlset->index > CHNLSET_MAX ))
1008                        return( EINVAL );
1009
1010        memcpy(&chnlset->name, &freqTable[chnlset->index].name,
1011                BT848_MAX_CHNLSET_NAME_LEN);
1012
1013        chnlset->max_channel=freqTable[chnlset->index].ptr[0];
1014        return( 0 );
1015 }
1016
1017
1018
1019
1020 #define TDA9887_ADDR    0x86
1021
1022 static int
1023 TDA9887_init(bktr_ptr_t bktr, int output2_enable)
1024 {
1025         u_char addr = TDA9887_ADDR;
1026
1027         i2cWrite(bktr, addr, 0, output2_enable ? 0x50 : 0xd0);
1028         i2cWrite(bktr, addr, 1, 0x6e); /* takeover point / de-emphasis */
1029
1030         /* PAL BG: 0x09  PAL I: 0x0a  NTSC: 0x04 */
1031 #ifdef MT2032_NTSC
1032         i2cWrite(bktr, addr, 2, 0x04);
1033 #else
1034         i2cWrite(bktr, addr, 2, 0x09);
1035 #endif
1036         return 0;
1037 }
1038
1039
1040
1041 #define MT2032_OPTIMIZE_VCO      1
1042
1043 /* holds the value of XOGC register after init */
1044 static int      MT2032_XOGC = 4;
1045
1046 /* card.tuner_pllAddr not set during init */
1047 #define MT2032_ADDR             0xc0
1048
1049 #ifndef MT2032_ADDR
1050 #define MT2032_ADDR             (bktr->card.tuner_pllAddr)
1051 #endif
1052
1053 static int 
1054 _MT2032_GetRegister(bktr_ptr_t bktr, u_char regNum)
1055 {
1056         int             ch;
1057
1058         if (i2cWrite(bktr, MT2032_ADDR, regNum, -1) == -1) {
1059                 if (bootverbose)
1060                         printf("%s: MT2032 write failed (i2c addr %#x)\n",
1061                                 bktr_name(bktr), MT2032_ADDR);
1062                 return -1;
1063         }
1064         if ((ch = i2cRead(bktr, MT2032_ADDR + 1)) == -1) {
1065                 if (bootverbose)
1066                         printf("%s: MT2032 get register %d failed\n",
1067                                 bktr_name(bktr), regNum);
1068                 return -1;
1069         }
1070         return ch;
1071 }
1072
1073 static void 
1074 _MT2032_SetRegister(bktr_ptr_t bktr, u_char regNum, u_char data)
1075 {
1076         i2cWrite(bktr, MT2032_ADDR, regNum, data);
1077 }
1078
1079 #define MT2032_GetRegister(r)           _MT2032_GetRegister(bktr,r)
1080 #define MT2032_SetRegister(r,d)         _MT2032_SetRegister(bktr,r,d)
1081
1082
1083 int 
1084 mt2032_init(bktr_ptr_t bktr)
1085 {
1086         u_char            rdbuf[22];
1087         int             xogc, xok = 0;
1088         int             i;
1089         int             x;
1090
1091         TDA9887_init(bktr, 0);
1092
1093         for (i = 0; i < 21; i++) {
1094                 if ((x = MT2032_GetRegister(i)) == -1)
1095                         break;
1096                 rdbuf[i] = x;
1097         }
1098         if (i < 21)
1099                 return -1;
1100
1101         printf("%s: MT2032: Companycode=%02x%02x Part=%02x Revision=%02x\n",
1102                 bktr_name(bktr),
1103                 rdbuf[0x11], rdbuf[0x12], rdbuf[0x13], rdbuf[0x14]);
1104         if (rdbuf[0x13] != 4) {
1105                 printf("%s: MT2032 not found or unknown type\n", bktr_name(bktr));
1106                 return -1;
1107         }
1108
1109         /* Initialize Registers per spec. */
1110         MT2032_SetRegister(2, 0xff);
1111         MT2032_SetRegister(3, 0x0f);
1112         MT2032_SetRegister(4, 0x1f);
1113         MT2032_SetRegister(6, 0xe4);
1114         MT2032_SetRegister(7, 0x8f);
1115         MT2032_SetRegister(8, 0xc3);
1116         MT2032_SetRegister(9, 0x4e);
1117         MT2032_SetRegister(10, 0xec);
1118         MT2032_SetRegister(13, 0x32);
1119
1120         /* Adjust XOGC (register 7), wait for XOK */
1121         xogc = 7;
1122         do {
1123                 DELAY(10000);
1124                 xok = MT2032_GetRegister(0x0e) & 0x01;
1125                 if (xok == 1) {
1126                         break;
1127                 }
1128                 xogc--;
1129                 if (xogc == 3) {
1130                         xogc = 4;       /* min. 4 per spec */
1131                         break;
1132                 }
1133                 MT2032_SetRegister(7, 0x88 + xogc);
1134         } while (xok != 1);
1135
1136         TDA9887_init(bktr, 1);
1137
1138         MT2032_XOGC = xogc;
1139
1140         return 0;
1141 }
1142
1143 static int 
1144 MT2032_SpurCheck(int f1, int f2, int spectrum_from, int spectrum_to)
1145 {
1146         int             n1 = 1, n2, f;
1147
1148         f1 = f1 / 1000;         /* scale to kHz to avoid 32bit overflows */
1149         f2 = f2 / 1000;
1150         spectrum_from /= 1000;
1151         spectrum_to /= 1000;
1152
1153         do {
1154                 n2 = -n1;
1155                 f = n1 * (f1 - f2);
1156                 do {
1157                         n2--;
1158                         f = f - f2;
1159                         if ((f > spectrum_from) && (f < spectrum_to)) {
1160                                 return 1;
1161                         }
1162                 } while ((f > (f2 - spectrum_to)) || (n2 > -5));
1163                 n1++;
1164         } while (n1 < 5);
1165
1166         return 0;
1167 }
1168
1169 static int
1170 MT2032_ComputeFreq(
1171                    int rfin,
1172                    int if1,
1173                    int if2,
1174                    int spectrum_from,
1175                    int spectrum_to,
1176                    unsigned char *buf,
1177                    int *ret_sel,
1178                    int xogc
1179 )
1180 {                               /* all in Hz */
1181         int             fref, lo1, lo1n, lo1a, s, sel;
1182         int             lo1freq, desired_lo1, desired_lo2, lo2, lo2n, lo2a,
1183                         lo2num, lo2freq;
1184         int             nLO1adjust;
1185
1186         fref = 5250 * 1000;     /* 5.25MHz */
1187
1188         /* per spec 2.3.1 */
1189         desired_lo1 = rfin + if1;
1190         lo1 = (2 * (desired_lo1 / 1000) + (fref / 1000)) / (2 * fref / 1000);
1191         lo1freq = lo1 * fref;
1192         desired_lo2 = lo1freq - rfin - if2;
1193
1194         /* per spec 2.3.2 */
1195         for (nLO1adjust = 1; nLO1adjust < 3; nLO1adjust++) {
1196                 if (!MT2032_SpurCheck(lo1freq, desired_lo2, spectrum_from, spectrum_to)) {
1197                         break;
1198                 }
1199                 if (lo1freq < desired_lo1) {
1200                         lo1 += nLO1adjust;
1201                 } else {
1202                         lo1 -= nLO1adjust;
1203                 }
1204
1205                 lo1freq = lo1 * fref;
1206                 desired_lo2 = lo1freq - rfin - if2;
1207         }
1208
1209         /* per spec 2.3.3 */
1210         s = lo1freq / 1000 / 1000;
1211
1212         if (MT2032_OPTIMIZE_VCO) {
1213                 if (s > 1890) {
1214                         sel = 0;
1215                 } else if (s > 1720) {
1216                         sel = 1;
1217                 } else if (s > 1530) {
1218                         sel = 2;
1219                 } else if (s > 1370) {
1220                         sel = 3;
1221                 } else {
1222                         sel = 4;/* >1090 */
1223                 }
1224         } else {
1225                 if (s > 1790) {
1226                         sel = 0;/* <1958 */
1227                 } else if (s > 1617) {
1228                         sel = 1;
1229                 } else if (s > 1449) {
1230                         sel = 2;
1231                 } else if (s > 1291) {
1232                         sel = 3;
1233                 } else {
1234                         sel = 4;/* >1090 */
1235                 }
1236         }
1237
1238         *ret_sel = sel;
1239
1240         /* per spec 2.3.4 */
1241         lo1n = lo1 / 8;
1242         lo1a = lo1 - (lo1n * 8);
1243         lo2 = desired_lo2 / fref;
1244         lo2n = lo2 / 8;
1245         lo2a = lo2 - (lo2n * 8);
1246         /* scale to fit in 32bit arith */
1247         lo2num = ((desired_lo2 / 1000) % (fref / 1000)) * 3780 / (fref / 1000);
1248         lo2freq = (lo2a + 8 * lo2n) * fref + lo2num * (fref / 1000) / 3780 * 1000;
1249
1250         if (lo1a < 0 || lo1a > 7 || lo1n < 17 || lo1n > 48 || lo2a < 0 ||
1251             lo2a > 7 || lo2n < 17 || lo2n > 30) {
1252                 printf("MT2032: parameter out of range\n");
1253                 return -1;
1254         }
1255         /* set up MT2032 register map for transfer over i2c */
1256         buf[0] = lo1n - 1;
1257         buf[1] = lo1a | (sel << 4);
1258         buf[2] = 0x86;          /* LOGC */
1259         buf[3] = 0x0f;          /* reserved */
1260         buf[4] = 0x1f;
1261         buf[5] = (lo2n - 1) | (lo2a << 5);
1262         if (rfin < 400 * 1000 * 1000) {
1263                 buf[6] = 0xe4;
1264         } else {
1265                 buf[6] = 0xf4;  /* set PKEN per rev 1.2 */
1266         }
1267
1268         buf[7] = 8 + xogc;
1269         buf[8] = 0xc3;          /* reserved */
1270         buf[9] = 0x4e;          /* reserved */
1271         buf[10] = 0xec;         /* reserved */
1272         buf[11] = (lo2num & 0xff);
1273         buf[12] = (lo2num >> 8) | 0x80; /* Lo2RST */
1274
1275         return 0;
1276 }
1277
1278 static int 
1279 MT2032_CheckLOLock(bktr_ptr_t bktr)
1280 {
1281         int             t, lock = 0;
1282         for (t = 0; t < 10; t++) {
1283                 lock = MT2032_GetRegister(0x0e) & 0x06;
1284                 if (lock == 6) {
1285                         break;
1286                 }
1287                 DELAY(1000);
1288         }
1289         return lock;
1290 }
1291
1292 static int 
1293 MT2032_OptimizeVCO(bktr_ptr_t bktr, int sel, int lock)
1294 {
1295         int             tad1, lo1a;
1296
1297         tad1 = MT2032_GetRegister(0x0f) & 0x07;
1298
1299         if (tad1 == 0) {
1300                 return lock;
1301         }
1302         if (tad1 == 1) {
1303                 return lock;
1304         }
1305         if (tad1 == 2) {
1306                 if (sel == 0) {
1307                         return lock;
1308                 } else {
1309                         sel--;
1310                 }
1311         } else {
1312                 if (sel < 4) {
1313                         sel++;
1314                 } else {
1315                         return lock;
1316                 }
1317         }
1318         lo1a = MT2032_GetRegister(0x01) & 0x07;
1319         MT2032_SetRegister(0x01, lo1a | (sel << 4));
1320         lock = MT2032_CheckLOLock(bktr);
1321         return lock;
1322 }
1323
1324 static int
1325 MT2032_SetIFFreq(bktr_ptr_t bktr, int rfin, int if1, int if2, int from, int to)
1326 {
1327         u_char          buf[21];
1328         int             lint_try, sel, lock = 0;
1329
1330         if (MT2032_ComputeFreq(rfin, if1, if2, from, to, &buf[0], &sel, MT2032_XOGC) == -1)
1331                 return -1;
1332
1333         TDA9887_init(bktr, 0);
1334
1335         /* send only the relevant registers per Rev. 1.2 */
1336         MT2032_SetRegister(0, buf[0x00]);
1337         MT2032_SetRegister(1, buf[0x01]);
1338         MT2032_SetRegister(2, buf[0x02]);
1339
1340         MT2032_SetRegister(5, buf[0x05]);
1341         MT2032_SetRegister(6, buf[0x06]);
1342         MT2032_SetRegister(7, buf[0x07]);
1343
1344         MT2032_SetRegister(11, buf[0x0B]);
1345         MT2032_SetRegister(12, buf[0x0C]);
1346
1347         /* wait for PLLs to lock (per manual), retry LINT if not. */
1348         for (lint_try = 0; lint_try < 2; lint_try++) {
1349                 lock = MT2032_CheckLOLock(bktr);
1350
1351                 if (MT2032_OPTIMIZE_VCO) {
1352                         lock = MT2032_OptimizeVCO(bktr, sel, lock);
1353                 }
1354                 if (lock == 6) {
1355                         break;
1356                 }
1357                 /* set LINT to re-init PLLs */
1358                 MT2032_SetRegister(7, 0x80 + 8 + MT2032_XOGC);
1359                 DELAY(10000);
1360                 MT2032_SetRegister(7, 8 + MT2032_XOGC);
1361         }
1362         if (lock != 6)
1363                 printf("%s: PLL didn't lock\n", bktr_name(bktr));
1364
1365         MT2032_SetRegister(2, 0x20);
1366
1367         TDA9887_init(bktr, 1);
1368         return 0;
1369 }
1370
1371 static void
1372 mt2032_set_tv_freq(bktr_ptr_t bktr, unsigned int freq)
1373 {
1374         int if2,from,to;
1375         int stat, tad;
1376
1377 #ifdef MT2032_NTSC
1378         from=40750*1000;
1379         to=46750*1000;
1380         if2=45750*1000;
1381 #else
1382         from=32900*1000;
1383         to=39900*1000;
1384         if2=38900*1000;
1385 #endif
1386
1387         if (MT2032_SetIFFreq(bktr, freq*62500 /* freq*1000*1000/16 */,
1388                         1090*1000*1000, if2, from, to) == 0) {
1389                 bktr->tuner.frequency = freq;
1390                 stat = MT2032_GetRegister(0x0e);
1391                 tad = MT2032_GetRegister(0x0f);
1392                 if (bootverbose)
1393                         printf("%s: frequency set to %d, st = %#x, tad = %#x\n",
1394                                 bktr_name(bktr), freq*62500, stat, tad);
1395         }
1396 }