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.12 2003/12/08 07:59:18 obrien Exp $
  34  * $DragonFly: src/sys/dev/video/bktr/bktr_tuner.c,v 1.6 2004/05/15 17:54:13 joerg 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 const struct TUNER tuners[] = {
 121 /* XXX FIXME: fill in the band-switch crosspoints */
 122         /* NO_TUNER */
 123         { "<no>",                               /* the 'name' */
 124            TTYPE_XXX,                           /* input type */
 125            { 0x00,                              /* control byte for Tuner PLL */
 126              0x00,
 127              0x00,
 128              0x00 },
 129            { 0x00, 0x00 },                      /* band-switch crosspoints */
 130            { 0x00, 0x00, 0x00,0x00} },          /* the band-switch values */
 131
 132         /* TEMIC_NTSC */
 133         { "Temic NTSC",                         /* the 'name' */
 134            TTYPE_NTSC,                          /* input type */
 135            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 136              TSA552x_SCONTROL,
 137              TSA552x_SCONTROL,
 138              0x00 },
 139            { 0x00, 0x00},                       /* band-switch crosspoints */
 140            { 0x02, 0x04, 0x01, 0x00 } },        /* the band-switch values */
 141
 142         /* TEMIC_PAL */
 143         { "Temic PAL",                          /* the 'name' */
 144            TTYPE_PAL,                           /* input type */
 145            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 146              TSA552x_SCONTROL,
 147              TSA552x_SCONTROL,
 148              0x00 },
 149            { 0x00, 0x00 },                      /* band-switch crosspoints */
 150            { 0x02, 0x04, 0x01, 0x00 } },        /* the band-switch values */
 151
 152         /* TEMIC_SECAM */
 153         { "Temic SECAM",                        /* the 'name' */
 154            TTYPE_SECAM,                         /* input type */
 155            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 156              TSA552x_SCONTROL,
 157              TSA552x_SCONTROL,
 158              0x00 },
 159            { 0x00, 0x00 },                      /* band-switch crosspoints */
 160            { 0x02, 0x04, 0x01,0x00 } },         /* the band-switch values */
 161
 162         /* PHILIPS_NTSC */
 163         { "Philips NTSC",                       /* the 'name' */
 164            TTYPE_NTSC,                          /* input type */
 165            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 166              TSA552x_SCONTROL,
 167              TSA552x_SCONTROL,
 168              0x00 },
 169            { 0x00, 0x00 },                      /* band-switch crosspoints */
 170            { 0xa0, 0x90, 0x30, 0x00 } },        /* the band-switch values */
 171
 172         /* PHILIPS_PAL */
 173         { "Philips PAL",                        /* the 'name' */
 174            TTYPE_PAL,                           /* input type */
 175            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 176              TSA552x_SCONTROL,
 177              TSA552x_SCONTROL,
 178              0x00 },
 179            { 0x00, 0x00 },                      /* band-switch crosspoints */
 180            { 0xa0, 0x90, 0x30, 0x00 } },        /* the band-switch values */
 181
 182         /* PHILIPS_SECAM */
 183         { "Philips SECAM",                      /* the 'name' */
 184            TTYPE_SECAM,                         /* input type */
 185            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 186              TSA552x_SCONTROL,
 187              TSA552x_SCONTROL,
 188              0x00 },
 189            { 0x00, 0x00 },                      /* band-switch crosspoints */
 190            { 0xa7, 0x97, 0x37, 0x00 } },        /* the band-switch values */
 191
 192         /* TEMIC_PAL I */
 193         { "Temic PAL I",                        /* the 'name' */
 194            TTYPE_PAL,                           /* input type */
 195            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 196              TSA552x_SCONTROL,
 197              TSA552x_SCONTROL,
 198              0x00 },
 199            { 0x00, 0x00 },                      /* band-switch crosspoints */
 200            { 0x02, 0x04, 0x01,0x00 } },         /* the band-switch values */
 201
 202         /* PHILIPS_PALI */
 203         { "Philips PAL I",                      /* the 'name' */
 204            TTYPE_PAL,                           /* input type */
 205            { TSA552x_SCONTROL,                  /* control byte for Tuner PLL */
 206              TSA552x_SCONTROL,
 207              TSA552x_SCONTROL,
 208              0x00 },
 209           { 0x00, 0x00 },                      /* band-switch crosspoints */
 210           { 0xa0, 0x90, 0x30,0x00 } },         /* the band-switch values */
 211
 212        /* PHILIPS_FR1236_NTSC */
 213        { "Philips FR1236 NTSC FM",             /* the 'name' */
 214           TTYPE_NTSC,                          /* input type */
 215           { TSA552x_FCONTROL,                   /* control byte for Tuner PLL */
 216             TSA552x_FCONTROL,
 217             TSA552x_FCONTROL,
 218             TSA552x_RADIO  },
 219           { 0x00, 0x00 },                       /* band-switch crosspoints */
 220           { 0xa0, 0x90, 0x30,0xa4 } },          /* the band-switch values */
 221
 222         /* PHILIPS_FR1216_PAL */
 223         { "Philips FR1216 PAL FM" ,             /* the 'name' */
 224            TTYPE_PAL,                           /* input type */
 225            { TSA552x_FCONTROL,                  /* control byte for Tuner PLL */
 226              TSA552x_FCONTROL,
 227              TSA552x_FCONTROL,
 228              TSA552x_RADIO },
 229            { 0x00, 0x00 },                      /* band-switch crosspoints */
 230            { 0xa0, 0x90, 0x30, 0xa4 } },        /* the band-switch values */
 231
 232         /* PHILIPS_FR1236_SECAM */
 233         { "Philips FR1236 SECAM FM",            /* the 'name' */
 234            TTYPE_SECAM,                         /* input type */
 235            { TSA552x_FCONTROL,                  /* control byte for Tuner PLL */
 236              TSA552x_FCONTROL,
 237              TSA552x_FCONTROL,
 238              TSA552x_RADIO },
 239            { 0x00, 0x00 },                      /* band-switch crosspoints */
 240            { 0xa7, 0x97, 0x37, 0xa4 } },        /* the band-switch values */
 241
 242         /* ALPS TSCH5 NTSC */
 243         { "ALPS TSCH5 NTSC FM",                 /* the 'name' */
 244            TTYPE_NTSC,                          /* input type */
 245            { TSCH5_FCONTROL,                    /* control byte for Tuner PLL */
 246              TSCH5_FCONTROL,
 247              TSCH5_FCONTROL,
 248              TSCH5_RADIO },
 249            { 0x00, 0x00 },                      /* band-switch crosspoints */
 250            { 0x14, 0x12, 0x11, 0x04 } },        /* the band-switch values */
 251
 252         /* ALPS TSBH1 NTSC */
 253         { "ALPS TSBH1 NTSC",                    /* the 'name' */
 254            TTYPE_NTSC,                          /* input type */
 255            { TSBH1_FCONTROL,                    /* control byte for Tuner PLL */
 256              TSBH1_FCONTROL,
 257              TSBH1_FCONTROL,
 258              0x00 },
 259            { 0x00, 0x00 },                      /* band-switch crosspoints */
 260            { 0x01, 0x02, 0x08, 0x00 } }         /* the band-switch values */
 261 };
 262
 263
 264 /* scaling factor for frequencies expressed as ints */
 265 #define FREQFACTOR              16
 266
 267 /*
 268  * Format:
 269  *      entry 0:         MAX legal channel
 270  *      entry 1:         IF frequency
 271  *                       expressed as fi{mHz} * 16,
 272  *                       eg 45.75mHz == 45.75 * 16 = 732
 273  *      entry 2:         [place holder/future]
 274  *      entry 3:         base of channel record 0
 275  *      entry 3 + (x*3): base of channel record 'x'
 276  *      entry LAST:      NULL channel entry marking end of records
 277  *
 278  * Record:
 279  *      int 0:          base channel
 280  *      int 1:          frequency of base channel,
 281  *                       expressed as fb{mHz} * 16,
 282  *      int 2:          offset frequency between channels,
 283  *                       expressed as fo{mHz} * 16,
 284  */
 285
 286 /*
 287  * North American Broadcast Channels:
 288  *
 289  *  2:  55.25 mHz -  4:  67.25 mHz
 290  *  5:  77.25 mHz -  6:  83.25 mHz
 291  *  7: 175.25 mHz - 13: 211.25 mHz
 292  * 14: 471.25 mHz - 83: 885.25 mHz
 293  *
 294  * IF freq: 45.75 mHz
 295  */
 296 #define OFFSET  6.00
 297 static int nabcst[] = {
 298         83,     (int)( 45.75 * FREQFACTOR),     0,
 299         14,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 300          7,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 301          5,     (int)( 77.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 302          2,     (int)( 55.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 303          0
 304 };
 305 #undef OFFSET
 306
 307 /*
 308  * North American Cable Channels, IRC:
 309  *
 310  *  2:  55.25 mHz -  4:  67.25 mHz
 311  *  5:  77.25 mHz -  6:  83.25 mHz
 312  *  7: 175.25 mHz - 13: 211.25 mHz
 313  * 14: 121.25 mHz - 22: 169.25 mHz
 314  * 23: 217.25 mHz - 94: 643.25 mHz
 315  * 95:  91.25 mHz - 99: 115.25 mHz
 316  *
 317  * IF freq: 45.75 mHz
 318  */
 319 #define OFFSET  6.00
 320 static int irccable[] = {
 321         116,    (int)( 45.75 * FREQFACTOR),     0,
 322         100,    (int)(649.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 323         95,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 324         23,     (int)(217.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 325         14,     (int)(121.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 326          7,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 327          5,     (int)( 77.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 328          2,     (int)( 55.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 329          0
 330 };
 331 #undef OFFSET
 332
 333 /*
 334  * North American Cable Channels, HRC:
 335  *
 336  * 2:   54 mHz  - 4:    66 mHz
 337  * 5:   78 mHz  - 6:    84 mHz
 338  * 7:  174 mHz  - 13:  210 mHz
 339  * 14: 120 mHz  - 22:  168 mHz
 340  * 23: 216 mHz  - 94:  642 mHz
 341  * 95:  90 mHz  - 99:  114 mHz
 342  *
 343  * IF freq: 45.75 mHz
 344  */
 345 #define OFFSET  6.00
 346 static int hrccable[] = {
 347         116,    (int)( 45.75 * FREQFACTOR),     0,
 348         100,    (int)(648.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 349         95,     (int)( 90.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 350         23,     (int)(216.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 351         14,     (int)(120.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 352         7,      (int)(174.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 353         5,      (int)( 78.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 354         2,      (int)( 54.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 355         0
 356 };
 357 #undef OFFSET
 358
 359 /*
 360  * Western European broadcast channels:
 361  *
 362  * (there are others that appear to vary between countries - rmt)
 363  *
 364  * here's the table Philips provides:
 365  * caution, some of the offsets don't compute...
 366  *
 367  *  1    4525   700     N21
 368  *
 369  *  2    4825   700     E2
 370  *  3    5525   700     E3
 371  *  4    6225   700     E4
 372  *
 373  *  5   17525   700     E5
 374  *  6   18225   700     E6
 375  *  7   18925   700     E7
 376  *  8   19625   700     E8
 377  *  9   20325   700     E9
 378  * 10   21025   700     E10
 379  * 11   21725   700     E11
 380  * 12   22425   700     E12
 381  *
 382  * 13    5375   700     ITA
 383  * 14    6225   700     ITB
 384  *
 385  * 15    8225   700     ITC
 386  *
 387  * 16   17525   700     ITD
 388  * 17   18325   700     ITE
 389  *
 390  * 18   19225   700     ITF
 391  * 19   20125   700     ITG
 392  * 20   21025   700     ITH
 393  *
 394  * 21   47125   800     E21
 395  * 22   47925   800     E22
 396  * 23   48725   800     E23
 397  * 24   49525   800     E24
 398  * 25   50325   800     E25
 399  * 26   51125   800     E26
 400  * 27   51925   800     E27
 401  * 28   52725   800     E28
 402  * 29   53525   800     E29
 403  * 30   54325   800     E30
 404  * 31   55125   800     E31
 405  * 32   55925   800     E32
 406  * 33   56725   800     E33
 407  * 34   57525   800     E34
 408  * 35   58325   800     E35
 409  * 36   59125   800     E36
 410  * 37   59925   800     E37
 411  * 38   60725   800     E38
 412  * 39   61525   800     E39
 413  * 40   62325   800     E40
 414  * 41   63125   800     E41
 415  * 42   63925   800     E42
 416  * 43   64725   800     E43
 417  * 44   65525   800     E44
 418  * 45   66325   800     E45
 419  * 46   67125   800     E46
 420  * 47   67925   800     E47
 421  * 48   68725   800     E48
 422  * 49   69525   800     E49
 423  * 50   70325   800     E50
 424  * 51   71125   800     E51
 425  * 52   71925   800     E52
 426  * 53   72725   800     E53
 427  * 54   73525   800     E54
 428  * 55   74325   800     E55
 429  * 56   75125   800     E56
 430  * 57   75925   800     E57
 431  * 58   76725   800     E58
 432  * 59   77525   800     E59
 433  * 60   78325   800     E60
 434  * 61   79125   800     E61
 435  * 62   79925   800     E62
 436  * 63   80725   800     E63
 437  * 64   81525   800     E64
 438  * 65   82325   800     E65
 439  * 66   83125   800     E66
 440  * 67   83925   800     E67
 441  * 68   84725   800     E68
 442  * 69   85525   800     E69
 443  *
 444  * 70    4575   800     IA
 445  * 71    5375   800     IB
 446  * 72    6175   800     IC
 447  *
 448  * 74    6925   700     S01
 449  * 75    7625   700     S02
 450  * 76    8325   700     S03
 451  *
 452  * 80   10525   700     S1
 453  * 81   11225   700     S2
 454  * 82   11925   700     S3
 455  * 83   12625   700     S4
 456  * 84   13325   700     S5
 457  * 85   14025   700     S6
 458  * 86   14725   700     S7
 459  * 87   15425   700     S8
 460  * 88   16125   700     S9
 461  * 89   16825   700     S10
 462  * 90   23125   700     S11
 463  * 91   23825   700     S12
 464  * 92   24525   700     S13
 465  * 93   25225   700     S14
 466  * 94   25925   700     S15
 467  * 95   26625   700     S16
 468  * 96   27325   700     S17
 469  * 97   28025   700     S18
 470  * 98   28725   700     S19
 471  * 99   29425   700     S20
 472  *
 473  *
 474  * Channels S21 - S41 are taken from
 475  * http://gemma.apple.com:80/dev/technotes/tn/tn1012.html
 476  *
 477  * 100  30325   800     S21
 478  * 101  31125   800     S22
 479  * 102  31925   800     S23
 480  * 103  32725   800     S24
 481  * 104  33525   800     S25
 482  * 105  34325   800     S26
 483  * 106  35125   800     S27
 484  * 107  35925   800     S28
 485  * 108  36725   800     S29
 486  * 109  37525   800     S30
 487  * 110  38325   800     S31
 488  * 111  39125   800     S32
 489  * 112  39925   800     S33
 490  * 113  40725   800     S34
 491  * 114  41525   800     S35
 492  * 115  42325   800     S36
 493  * 116  43125   800     S37
 494  * 117  43925   800     S38
 495  * 118  44725   800     S39
 496  * 119  45525   800     S40
 497  * 120  46325   800     S41
 498  *
 499  * 121   3890   000     IFFREQ
 500  *
 501  */
 502 static int weurope[] = {
 503        121,     (int)( 38.90 * FREQFACTOR),     0,
 504        100,     (int)(303.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 505         90,     (int)(231.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
 506         80,     (int)(105.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
 507         74,     (int)( 69.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
 508         21,     (int)(471.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 509         17,     (int)(183.25 * FREQFACTOR),     (int)(9.00 * FREQFACTOR),
 510         16,     (int)(175.25 * FREQFACTOR),     (int)(9.00 * FREQFACTOR),
 511         15,     (int)(82.25 * FREQFACTOR),      (int)(8.50 * FREQFACTOR),
 512         13,     (int)(53.75 * FREQFACTOR),      (int)(8.50 * FREQFACTOR),
 513          5,     (int)(175.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
 514          2,     (int)(48.25 * FREQFACTOR),      (int)(7.00 * FREQFACTOR),
 515          0
 516 };
 517
 518 /*
 519  * Japanese Broadcast Channels:
 520  *
 521  *  1:  91.25MHz -  3: 103.25MHz
 522  *  4: 171.25MHz -  7: 189.25MHz
 523  *  8: 193.25MHz - 12: 217.25MHz  (VHF)
 524  * 13: 471.25MHz - 62: 765.25MHz  (UHF)
 525  *
 526  * IF freq: 45.75 mHz
 527  *  OR
 528  * IF freq: 58.75 mHz
 529  */
 530 #define OFFSET  6.00
 531 #define IF_FREQ 45.75
 532 static int jpnbcst[] = {
 533         62,     (int)(IF_FREQ * FREQFACTOR),    0,
 534         13,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 535          8,     (int)(193.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 536          4,     (int)(171.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 537          1,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 538          0
 539 };
 540 #undef IF_FREQ
 541 #undef OFFSET
 542
 543 /*
 544  * Japanese Cable Channels:
 545  *
 546  *  1:  91.25MHz -  3: 103.25MHz
 547  *  4: 171.25MHz -  7: 189.25MHz
 548  *  8: 193.25MHz - 12: 217.25MHz
 549  * 13: 109.25MHz - 21: 157.25MHz
 550  * 22: 165.25MHz
 551  * 23: 223.25MHz - 63: 463.25MHz
 552  *
 553  * IF freq: 45.75 mHz
 554  */
 555 #define OFFSET  6.00
 556 #define IF_FREQ 45.75
 557 static int jpncable[] = {
 558         63,     (int)(IF_FREQ * FREQFACTOR),    0,
 559         23,     (int)(223.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 560         22,     (int)(165.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 561         13,     (int)(109.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 562          8,     (int)(193.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 563          4,     (int)(171.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 564          1,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 565          0
 566 };
 567 #undef IF_FREQ
 568 #undef OFFSET
 569
 570 /*
 571  * xUSSR Broadcast Channels:
 572  *
 573  *  1:  49.75MHz -  2:  59.25MHz
 574  *  3:  77.25MHz -  5:  93.25MHz
 575  *  6: 175.25MHz - 12: 223.25MHz
 576  * 13-20 - not exist
 577  * 21: 471.25MHz - 34: 575.25MHz
 578  * 35: 583.25MHz - 69: 855.25MHz
 579  *
 580  * Cable channels
 581  *
 582  * 70: 111.25MHz - 77: 167.25MHz
 583  * 78: 231.25MHz -107: 463.25MHz
 584  *
 585  * IF freq: 38.90 MHz
 586  */
 587 #define IF_FREQ 38.90
 588 static int xussr[] = {
 589       107,     (int)(IF_FREQ * FREQFACTOR),    0,
 590        78,     (int)(231.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 591        70,     (int)(111.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 592        35,     (int)(583.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 593        21,     (int)(471.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 594         6,     (int)(175.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 595         3,     (int)( 77.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
 596         1,     (int)( 49.75 * FREQFACTOR),     (int)(9.50 * FREQFACTOR),
 597         0
 598 };
 599 #undef IF_FREQ
 600
 601 /*
 602  * Australian broadcast channels
 603  */
 604 #define OFFSET  7.00
 605 #define IF_FREQ 38.90
 606 static int australia[] = {
 607        83,     (int)(IF_FREQ * FREQFACTOR),    0,
 608        28,     (int)(527.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 609        10,     (int)(209.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 610         6,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 611         4,     (int)( 95.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 612         3,     (int)( 86.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 613         1,     (int)( 57.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
 614         0
 615 };
 616 #undef OFFSET
 617 #undef IF_FREQ
 618
 619 /*
 620  * France broadcast channels
 621  */
 622 #define OFFSET 8.00
 623 #define IF_FREQ 38.90
 624 static int france[] = {
 625         69,     (int)(IF_FREQ * FREQFACTOR),     0,
 626         21,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 21 -> 69 */
 627          5,     (int)(176.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 5 -> 10 */
 628          4,     (int)( 63.75 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 4    */
 629          3,     (int)( 60.50 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 3    */
 630          1,     (int)( 47.75 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 1  2 */
 631          0
 632 };
 633 #undef OFFSET
 634 #undef IF_FREQ
 635
 636 static struct {
 637         int     *ptr;
 638         char    name[BT848_MAX_CHNLSET_NAME_LEN];
 639 } freqTable[] = {
 640         {NULL,          ""},
 641         {nabcst,        "nabcst"},
 642         {irccable,      "cableirc"},
 643         {hrccable,      "cablehrc"},
 644         {weurope,       "weurope"},
 645         {jpnbcst,       "jpnbcst"},
 646         {jpncable,      "jpncable"},
 647         {xussr,         "xussr"},
 648         {australia,     "australia"},
 649         {france,        "france"},
 650
 651 };
 652
 653 #define TBL_CHNL        freqTable[ bktr->tuner.chnlset ].ptr[ x ]
 654 #define TBL_BASE_FREQ   freqTable[ bktr->tuner.chnlset ].ptr[ x + 1 ]
 655 #define TBL_OFFSET      freqTable[ bktr->tuner.chnlset ].ptr[ x + 2 ]
 656 static int
 657 frequency_lookup( bktr_ptr_t bktr, int channel )
 658 {
 659         int     x;
 660
 661         /* check for "> MAX channel" */
 662         x = 0;
 663         if ( channel > TBL_CHNL )
 664                 return( -1 );
 665
 666         /* search the table for data */
 667         for ( x = 3; TBL_CHNL; x += 3 ) {
 668                 if ( channel >= TBL_CHNL ) {
 669                         return( TBL_BASE_FREQ +
 670                                  ((channel - TBL_CHNL) * TBL_OFFSET) );
 671                 }
 672         }
 673
 674         /* not found, must be below the MIN channel */
 675         return( -1 );
 676 }
 677 #undef TBL_OFFSET
 678 #undef TBL_BASE_FREQ
 679 #undef TBL_CHNL
 680
 681
 682 #define TBL_IF  freqTable[ bktr->tuner.chnlset ].ptr[ 1 ]
 683
 684
 685 /* Initialise the tuner structures in the bktr_softc */
 686 /* This is needed as the tuner details are no longer globally declared */
 687
 688 void    select_tuner( bktr_ptr_t bktr, int tuner_type ) {
 689         if (tuner_type < Bt848_MAX_TUNER) {
 690                 bktr->card.tuner = &tuners[ tuner_type ];
 691         } else {
 692                 bktr->card.tuner = NULL;
 693         }
 694 }
 695
 696 /*
 697  * Tuner Notes:
 698  * Programming the tuner properly is quite complicated.
 699  * Here are some notes, based on a FM1246 data sheet for a PAL-I tuner.
 700  * The tuner (front end) covers 45.75 Mhz - 855.25 Mhz and an FM band of
 701  * 87.5 Mhz to 108.0 Mhz.
 702  *
 703  * RF and IF.  RF = radio frequencies, it is the transmitted signal.
 704  *             IF is the Intermediate Frequency (the offset from the base
 705  *             signal where the video, color,  audio and NICAM signals are.
 706  *
 707  * Eg, Picture at 38.9 Mhz, Colour at 34.47 MHz, sound at 32.9 MHz
 708  * NICAM at 32.348 Mhz.
 709  * Strangely enough, there is an IF (intermediate frequency) for
 710  * FM Radio which is 10.7 Mhz.
 711  *
 712  * The tuner also works in Bands. Philips bands are
 713  * FM radio band 87.50 to 108.00 MHz
 714  * Low band 45.75 to 170.00 MHz
 715  * Mid band 170.00 to 450.00 MHz
 716  * High band 450.00 to 855.25 MHz
 717  *
 718  *
 719  * Now we need to set the PLL on the tuner to the required freuqncy.
 720  * It has a programmable divisor.
 721  * For TV we want
 722  *  N = 16 (freq RF(pc) + freq IF(pc))  pc is picture carrier and RF and IF
 723  *  are in MHz.
 724
 725  * For RADIO we want a different equation.
 726  *  freq IF is 10.70 MHz (so the data sheet tells me)
 727  * N = (freq RF + freq IF) / step size
 728  * The step size must be set to 50 khz (so the data sheet tells me)
 729  * (note this is 50 kHz, the other things are in MHz)
 730  * so we end up with N = 20x(freq RF + 10.7)
 731  *
 732  */
 733
 734 #define LOW_BAND 0
 735 #define MID_BAND 1
 736 #define HIGH_BAND 2
 737 #define FM_RADIO_BAND 3
 738
 739
 740 /* Check if these are correct for other than Philips PAL */
 741 #define STATUSBIT_COLD   0x80
 742 #define STATUSBIT_LOCK   0x40
 743 #define STATUSBIT_TV     0x20
 744 #define STATUSBIT_STEREO 0x10 /* valid if FM (aka not TV) */
 745 #define STATUSBIT_ADC    0x07
 746
 747 /*
 748  * set the frequency of the tuner
 749  * If 'type' is TV_FREQUENCY, the frequency is freq MHz*16
 750  * If 'type' is FM_RADIO_FREQUENCY, the frequency is freq MHz * 100
 751  * (note *16 gives is 4 bits of fraction, eg steps of nnn.0625)
 752  *
 753  */
 754 int
 755 tv_freq( bktr_ptr_t bktr, int frequency, int type )
 756 {
 757         const struct TUNER*     tuner;
 758         u_char                  addr;
 759         u_char                  control;
 760         u_char                  band;
 761         int                     N;
 762         int                     band_select = 0;
 763 #if defined( TEST_TUNER_AFC )
 764         int                     oldFrequency, afcDelta;
 765 #endif
 766
 767         tuner = bktr->card.tuner;
 768         if ( tuner == NULL )
 769                 return( -1 );
 770
 771         if (type == TV_FREQUENCY) {
 772                 /*
 773                  * select the band based on frequency
 774                  * XXX FIXME: get the cross-over points from the tuner struct
 775                  */
 776                 if ( frequency < (160 * FREQFACTOR  ) )
 777                     band_select = LOW_BAND;
 778                 else if ( frequency < (454 * FREQFACTOR ) )
 779                     band_select = MID_BAND;
 780                 else
 781                     band_select = HIGH_BAND;
 782
 783 #if defined( TEST_TUNER_AFC )
 784                 if ( bktr->tuner.afc )
 785                         frequency -= 4;
 786 #endif
 787                 /*
 788                  * N = 16 * { fRF(pc) + fIF(pc) }
 789                  * or N = 16* fRF(pc) + 16*fIF(pc) }
 790                  * where:
 791                  *  pc is picture carrier, fRF & fIF are in MHz
 792                  *
 793                  * fortunatly, frequency is passed in as MHz * 16
 794                  * and the TBL_IF frequency is also stored in MHz * 16
 795                  */
 796                 N = frequency + TBL_IF;
 797
 798                 /* set the address of the PLL */
 799                 addr    = bktr->card.tuner_pllAddr;
 800                 control = tuner->pllControl[ band_select ];
 801                 band    = tuner->bandAddrs[ band_select ];
 802
 803                 if(!(band && control))          /* Don't try to set un- */
 804                   return(-1);                   /* supported modes.     */
 805
 806                 if ( frequency > bktr->tuner.frequency ) {
 807                         i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
 808                         i2cWrite( bktr, addr, control, band );
 809                 }
 810                 else {
 811                         i2cWrite( bktr, addr, control, band );
 812                         i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
 813                 }
 814
 815 #if defined( TUNER_AFC )
 816                 if ( bktr->tuner.afc == TRUE ) {
 817 #if defined( TEST_TUNER_AFC )
 818                         oldFrequency = frequency;
 819 #endif
 820                         if ( (N = do_afc( bktr, addr, N )) < 0 ) {
 821                             /* AFC failed, restore requested frequency */
 822                             N = frequency + TBL_IF;
 823 #if defined( TEST_TUNER_AFC )
 824                             printf("%s: do_afc: failed to lock\n",
 825                                    bktr_name(bktr));
 826 #endif
 827                             i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
 828                         }
 829                         else
 830                             frequency = N - TBL_IF;
 831 #if defined( TEST_TUNER_AFC )
 832  printf("%s: do_afc: returned freq %d (%d %% %d)\n", bktr_name(bktr), frequency, frequency / 16, frequency % 16);
 833                             afcDelta = frequency - oldFrequency;
 834  printf("%s: changed by: %d clicks (%d mod %d)\n", bktr_name(bktr), afcDelta, afcDelta / 16, afcDelta % 16);
 835 #endif
 836                         }
 837 #endif /* TUNER_AFC */
 838
 839                 bktr->tuner.frequency = frequency;
 840         }
 841
 842         if ( type == FM_RADIO_FREQUENCY ) {
 843                 band_select = FM_RADIO_BAND;
 844
 845                 /*
 846                  * N = { fRF(pc) + fIF(pc) }/step_size
 847                  * The step size is 50kHz for FM radio.
 848                  * (eg after 102.35MHz comes 102.40 MHz)
 849                  * fIF is 10.7 MHz (as detailed in the specs)
 850                  *
 851                  * frequency is passed in as MHz * 100
 852                  *
 853                  * So, we have N = (frequency/100 + 10.70)  /(50/1000)
 854                  */
 855                 N = (frequency + 1070)/5;
 856
 857                 /* set the address of the PLL */
 858                 addr    = bktr->card.tuner_pllAddr;
 859                 control = tuner->pllControl[ band_select ];
 860                 band    = tuner->bandAddrs[ band_select ];
 861
 862                 if(!(band && control))          /* Don't try to set un- */
 863                   return(-1);                   /* supported modes.     */
 864
 865                 band |= bktr->tuner.radio_mode; /* tuner.radio_mode is set in
 866                                                  * the ioctls RADIO_SETMODE
 867                                                  * and RADIO_GETMODE */
 868
 869                 i2cWrite( bktr, addr, control, band );
 870                 i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
 871
 872                 bktr->tuner.frequency = (N * 5) - 1070;
 873
 874
 875         }
 876
 877
 878         return( 0 );
 879 }
 880
 881
 882
 883 #if defined( TUNER_AFC )
 884 /*
 885  *
 886  */
 887 int
 888 do_afc( bktr_ptr_t bktr, int addr, int frequency )
 889 {
 890         int step;
 891         int status;
 892         int origFrequency;
 893
 894         origFrequency = frequency;
 895
 896         /* wait for first setting to take effect */
 897         tsleep( BKTR_SLEEP, 0, "tuning", hz/8 );
 898
 899         if ( (status = i2cRead( bktr, addr + 1 )) < 0 )
 900                 return( -1 );
 901
 902 #if defined( TEST_TUNER_AFC )
 903  printf( "%s: Original freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
 904 #endif
 905         for ( step = 0; step < AFC_MAX_STEP; ++step ) {
 906                 if ( (status = i2cRead( bktr, addr + 1 )) < 0 )
 907                         goto fubar;
 908                 if ( !(status & 0x40) ) {
 909 #if defined( TEST_TUNER_AFC )
 910  printf( "%s: no lock!\n", bktr_name(bktr) );
 911 #endif
 912                         goto fubar;
 913                 }
 914
 915                 switch( status & AFC_BITS ) {
 916                 case AFC_FREQ_CENTERED:
 917 #if defined( TEST_TUNER_AFC )
 918  printf( "%s: Centered, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
 919 #endif
 920                         return( frequency );
 921
 922                 case AFC_FREQ_MINUS_125:
 923                 case AFC_FREQ_MINUS_62:
 924 #if defined( TEST_TUNER_AFC )
 925  printf( "%s: Low, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
 926 #endif
 927                         --frequency;
 928                         break;
 929
 930                 case AFC_FREQ_PLUS_62:
 931                 case AFC_FREQ_PLUS_125:
 932 #if defined( TEST_TUNER_AFC )
 933  printf( "%s: Hi, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
 934 #endif
 935                         ++frequency;
 936                         break;
 937                 }
 938
 939                 i2cWrite( bktr, addr,
 940                           (frequency>>8) & 0x7f, frequency & 0xff );
 941                 DELAY( AFC_DELAY );
 942         }
 943
 944  fubar:
 945         i2cWrite( bktr, addr,
 946                   (origFrequency>>8) & 0x7f, origFrequency & 0xff );
 947
 948         return( -1 );
 949 }
 950 #endif /* TUNER_AFC */
 951 #undef TBL_IF
 952
 953
 954 /*
 955  * Get the Tuner status and signal strength
 956  */
 957 int     get_tuner_status( bktr_ptr_t bktr ) {
 958         return i2cRead( bktr, bktr->card.tuner_pllAddr + 1 );
 959 }
 960
 961 /*
 962  * set the channel of the tuner
 963  */
 964 int
 965 tv_channel( bktr_ptr_t bktr, int channel )
 966 {
 967         int frequency;
 968
 969         /* calculate the frequency according to tuner type */
 970         if ( (frequency = frequency_lookup( bktr, channel )) < 0 )
 971                 return( -1 );
 972
 973         /* set the new frequency */
 974         if ( tv_freq( bktr, frequency, TV_FREQUENCY ) < 0 )
 975                 return( -1 );
 976
 977         /* OK to update records */
 978         return( (bktr->tuner.channel = channel) );
 979 }
 980
 981 /*
 982  * get channelset name
 983  */
 984 int
 985 tuner_getchnlset(struct bktr_chnlset *chnlset)
 986 {
 987        if (( chnlset->index < CHNLSET_MIN ) ||
 988                ( chnlset->index > CHNLSET_MAX ))
 989                        return( EINVAL );
 990
 991        memcpy(&chnlset->name, &freqTable[chnlset->index].name,
 992                BT848_MAX_CHNLSET_NAME_LEN);
 993
 994        chnlset->max_channel=freqTable[chnlset->index].ptr[0];
 995        return( 0 );
 996 }