sys/src/9/pc/devtv.c

   1 /*
   2   * Driver for Bt848 TV tuner.
   3   *
   4   */
   5 #include        "u.h"
   6 #include        "../port/lib.h"
   7 #include        "mem.h"
   8 #include        "dat.h"
   9 #include        "fns.h"
  10 #include        "../port/error.h"
  11 #include "io.h"
  12 #include "hcwAMC.h"
  13
  14 #define max(a, b)       (((a) > (b))? (a): (b))
  15
  16 enum {
  17         Qdir = 0,
  18         Qsubdir,
  19         Qsubbase,
  20         Qvdata = Qsubbase,
  21         Qadata,
  22         Qctl,
  23         Qregs,
  24
  25         Brooktree_vid = 0x109e,
  26         Brooktree_848_did = 0x0350,
  27         Brooktree_878_did = 0x036E,
  28         Intel_vid = 0x8086,
  29         Intel_82437_did = 0x122d,
  30
  31         K = 1024,
  32         M = K * K,
  33
  34         Ntvs = 4,
  35
  36         Numring = 16,
  37
  38         ntsc_rawpixels = 910,
  39         ntsc_sqpixels = 780,            /* Including blanking & inactive */
  40         ntsc_hactive = 640,
  41         ntsc_vactive = 480,
  42         ntsc_clkx1delay = 135,          /* Clock ticks. */
  43         ntsc_clkx1hactive = 754,
  44         ntsc_vdelay = 26,               /* # of scan lines. */
  45         ntsc_vscale = 0,
  46
  47         i2c_nostop = 1 << 5,
  48         i2c_nos1b  = 1 << 4,
  49         i2c_timing = 7 << 4,
  50         i2c_bt848w3b = 1 << 2,
  51         i2c_bt848scl = 1 << 1,
  52         i2c_bt848sda = 1 << 0,
  53         i2c_scl = i2c_bt848scl,
  54         i2c_sda = i2c_bt848sda,
  55
  56         i2c_miroproee = 0x80,           /* MIRO PRO EEPROM */
  57         i2c_tea6300 = 0x80,
  58         i2c_tda8425 = 0x82,
  59         i2c_tda9840 = 0x84,
  60         i2c_tda9850 = 0xb6,
  61         i2c_haupee = 0xa0,              /* Hauppage EEPROM */
  62         i2c_stbee = 0xae,               /* STB EEPROM */
  63         i2c_msp3400 = 0x80,
  64
  65         i2c_timeout = 1000,
  66         i2c_delay = 10,
  67
  68         Bt848_miropro = 0,
  69         Bt848_miro,
  70         Bt878_hauppauge,
  71
  72         /* Bit fields. */
  73         iform_muxsel1 = 3 << 5,         /* 004 */
  74         iform_muxsel0 = 2 << 5,
  75         iform_xtselmask = 3 << 3,
  76         iform_xtauto = 3 << 3,
  77         iform_formatmask = 7 << 0,
  78         iform_ntsc = 1 << 0,
  79
  80         control_ldec = 1 << 5,          /* 02C */
  81         contrast_100percent = 0xd8,     /* 030 */
  82
  83         vscale_interlaced = 1 << 5,     /* 04C */
  84
  85         adelay_ntsc = 104,              /* 060 */
  86         bdelay_ntsc = 93,               /* 064 */
  87         adc_crush = 1 << 0,             /* 068 */
  88
  89         colorfmt_rgb16 = 2 << 4 | 2 << 0,       /* 0D4 */
  90         colorfmt_YCbCr422 = 8 << 4 | 8 << 0,
  91         colorfmt_YCbCr411 = 9 << 4 | 9 << 0,
  92         colorctl_gamma     = 1 << 4,    /* 0D8 */
  93         capctl_fullframe   = 1 << 4,    /* 0DC */
  94         capctl_captureodd  = 1 << 1,
  95         capctl_captureeven = 1 << 0,
  96         vbipacksize = 0x190,            /* 0E0 */
  97
  98         intstat_riscstatshift = 28,     /* 100 */
  99         intstat_i2crack = 1 << 25,
 100         intstat_scerr = 1 << 19,
 101         intstat_ocerr = 1 << 18,
 102         intstat_pabort = 1 << 17,
 103         intstat_riperr = 1 << 16,
 104         intstat_pperr = 1 << 15,
 105         intstat_fdsr = 1 << 14,
 106         intstat_ftrgt = 1 << 13,
 107         intstat_fbus = 1 << 12,
 108         intstat_risci = 1 << 11,
 109         intstat_i2cdone = 1 << 8,
 110         intstat_vpress = 1 << 5,
 111         intstat_hlock = 1 << 4,
 112         intstat_vsync = 1 << 1,
 113         intstat_fmtchg = 1 << 0,
 114         intmask_etbf = 1 << 23,         /* 104 */
 115
 116         gpiodmactl_apwrdn = 1 << 26,    /* 10C */
 117         gpiodmactl_daes2 = 1 << 13,
 118         gpiodmactl_daiomda = 1 << 6,
 119         gpiodmactl_pltp23_16 = 2 << 6,
 120         gpiodmactl_pltp23_0 = 0 << 6,
 121         gpiodmactl_pltp1_16 = 2 << 4,
 122         gpiodmactl_pltp1_0 = 0 << 4,
 123         gpiodmactl_acapenable = 1 << 4,
 124         gpiodmactl_pktp_32 = 3 << 2,
 125         gpiodmactl_pktp_0 = 0 << 2,
 126         gpiodmactl_riscenable = 1 << 1,
 127         gpiodmactl_fifoenable = 1 << 0,
 128
 129         /* RISC instructions and parameters. */
 130         fifo_vre = 0x4,
 131         fifo_vro = 0xc,
 132         fifo_fm1 = 0x6,
 133         fifo_fm3 = 0xe,
 134
 135         riscirq = 1 << 24,
 136         riscwrite = 1 << 28,
 137         riscwrite123 = 9 << 28,
 138         riscwrite1s23 = 11 << 28,
 139                 riscwrite_sol = 1 << 27,
 140                 riscwrite_eol = 1 << 26,
 141         riscskip = 0x2 << 28,
 142         riscjmp = 0x7 << 28,
 143         riscsync = 0x8 << 28,
 144                 riscsync_resync = 1 << 15,
 145                 riscsync_vre = fifo_vre << 0,
 146                 riscsync_vro = fifo_vro << 0,
 147                 riscsync_fm1 = fifo_fm1 << 0,
 148                 riscsync_fm3 = fifo_fm3 << 0,
 149         risclabelshift_set = 16,
 150         risclabelshift_reset = 20,
 151
 152         AudioTuner = 0,
 153         AudioRadio,
 154         AudioExtern,
 155         AudioIntern,
 156         AudioOff,
 157         AudioOn,
 158
 159         asel_tv = 0,
 160         asel_radio,
 161         asel_mic,
 162         asel_smxc,
 163
 164         Hwbase_ad = 448000,
 165
 166         msp_dem = 0x10,
 167         msp_bbp = 0x12,
 168
 169         /* Altera definitions. */
 170         gpio_altera_data = 1 << 0,
 171         gpio_altera_clock = 1 << 20,
 172         gpio_altera_nconfig = 1 << 23,
 173
 174         Ial = 0x140001,
 175         Idma = 0x100002,
 176
 177         Adsp = 0x7fd8,
 178         Adsp_verifysystem = 1,
 179         Adsp_querysupportplay,
 180         Adsp_setstyle,
 181         Adsp_setsrate,
 182         Adsp_setchannels,
 183         Adsp_setresolution,
 184         Adsp_setcrcoptions,
 185         Adsp_bufenqfor,
 186         Adsp_logbuffer,
 187         Adsp_startplay,
 188         Adsp_stopplay,
 189         Adsp_autostop,
 190         Adsp_startrecord,
 191         Adsp_stoprecord,
 192         Adsp_getlastprocessed,
 193         Adsp_pause,
 194         Adsp_resume,
 195         Adsp_setvolume,
 196         Adsp_querysupportrecord,
 197         Adsp_generalbufenq,
 198         Adsp_setdownmixtype,
 199         Adsp_setigain,
 200         Adsp_setlineout,
 201         Adsp_setlangmixtype,
 202
 203         Kfir_gc = 0,
 204         Kfir_dsp_riscmc,
 205         Kfir_dsp_risccram,
 206         Kfir_dsp_unitmc,
 207         Kfir_bsm_mc,
 208         Kfir_mux_mc,
 209
 210         Kfir_devid_gc = 7,
 211         Kfir_devid_dsp = 4,
 212         Kfir_devid_bsm = 5,
 213         Kfir_devid_mux = 8,
 214
 215         Kfir_200 = 200,
 216         Kfir_dev_inst = Kfir_200,
 217         Kfir_201 = 201,
 218         Kfir_exec = Kfir_201,
 219         Kfir_202 = 202,
 220         Kfir_adr_eready = 254,
 221
 222         Kfir_d_eready_encoding = 0,
 223         Kfir_d_eready_ready,
 224         Kfir_d_eready_test,
 225         Kfir_d_eready_stopdetect,
 226         Kfir_d_eready_seqend,
 227
 228         VT_KFIR_OFF = 0,
 229         VT_KFIR_ON,
 230
 231         VT_KFIR_LAYER_II = 1,
 232         VT_KFIR_STEREO = 1,
 233
 234         Gpioinit = 0,
 235         Gpiooutput,
 236         Gpioinput,
 237
 238         Srate_5512 = 0,
 239         Srate_11025 = 2,
 240         Srate_16000 = 3,
 241         Srate_22050 = 4,
 242         Srate_32000 = 5,
 243         Srate_44100 = 6,
 244         Srate_48000 = 7,
 245
 246 };
 247
 248 typedef struct Variant Variant;
 249 struct Variant {
 250         ushort  vid;
 251         ushort  did;
 252         char    *name;
 253 };
 254
 255 typedef struct Bt848 Bt848;
 256 struct Bt848 {
 257         ulong   devstat;        /* 000 */
 258         ulong   iform;          /* 004 */
 259         ulong   tdec;           /* 008 */
 260         ulong   ecrop;          /* 00C */
 261         ulong   evdelaylo;      /* 010 */
 262         ulong   evactivelo;     /* 014 */
 263         ulong   ehdelaylo;      /* 018 */
 264         ulong   ehactivelo;     /* 01C */
 265         ulong   ehscalehi;      /* 020 */
 266         ulong   ehscalelo;      /* 024 */
 267         ulong   bright;         /* 028 */
 268         ulong   econtrol;       /* 02C */
 269         ulong   contrastlo;     /* 030 */
 270         ulong   satulo;         /* 034 */
 271         ulong   satvlo;         /* 038 */
 272         ulong   hue;            /* 03C */
 273         ulong   escloop;        /* 040 */
 274         ulong   pad0;           /* 044 */
 275         ulong   oform;          /* 048 */
 276         ulong   evscalehi;      /* 04C */
 277         ulong   evscalelo;      /* 050 */
 278         ulong   test;           /* 054 */
 279         ulong   pad1[2];        /* 058-05C */
 280         ulong   adelay;         /* 060 */
 281         ulong   bdelay;         /* 064 */
 282         ulong   adc;            /* 068 */
 283         ulong   evtc;           /* 06C */
 284         ulong   pad2[3];        /* 070-078 */
 285         ulong   sreset;         /* 07C */
 286         ulong   tglb;           /* 080 */
 287         ulong   tgctrl;         /* 084 */
 288         ulong   pad3;           /* 088 */
 289         ulong   ocrop;          /* 08C */
 290         ulong   ovdelaylo;      /* 090 */
 291         ulong   ovactivelo;     /* 094 */
 292         ulong   ohdelaylo;      /* 098 */
 293         ulong   ohactivelo;     /* 09C */
 294         ulong   ohscalehi;      /* 0A0 */
 295         ulong   ohscalelo;      /* 0A4 */
 296         ulong   pad4;           /* 0A8 */
 297         ulong   ocontrol;       /* 0AC */
 298         ulong   pad5[4];        /* 0B0-0BC */
 299         ulong   oscloop;        /* 0C0 */
 300         ulong   pad6[2];        /* 0C4-0C8 */
 301         ulong   ovscalehi;      /* 0CC */
 302         ulong   ovscalelo;      /* 0D0 */
 303         ulong   colorfmt;       /* 0D4 */
 304         ulong   colorctl;       /* 0D8 */
 305         ulong   capctl;         /* 0DC */
 306         ulong   vbipacksize;    /* 0E0 */
 307         ulong   vbipackdel;     /* 0E4 */
 308         ulong   fcap;           /* 0E8 */
 309         ulong   ovtc;           /* 0EC */
 310         ulong   pllflo;         /* 0F0 */
 311         ulong   pllfhi;         /* 0F4 */
 312         ulong   pllxci;         /* 0F8 */
 313         ulong   dvsif;          /* 0FC */
 314         ulong   intstat;        /* 100 */
 315         ulong   intmask;        /* 104 */
 316         ulong   pad7;           /* 108 */
 317         ulong   gpiodmactl;     /* 10C */
 318         ulong   i2c;            /* 110 */
 319         ulong   riscstrtadd;    /* 114 */
 320         ulong   gpioouten;      /* 118 */
 321         ulong   gpioreginp;     /* 11C */
 322         ulong   risccount;      /* 120 */
 323         ulong   pad8[55];       /* 124-1FC */
 324         ulong   gpiodata[64];   /* 200-2FC */
 325 };
 326
 327 #define packetlen       i2c
 328
 329 typedef struct Tuner Tuner;
 330 struct Tuner {
 331         char    *name;
 332         ushort  freq_vhfh;      /* Start frequency */
 333         ushort  freq_uhf;
 334         uchar   VHF_L;
 335         uchar   VHF_H;
 336         uchar   UHF;
 337         uchar   cfg;
 338         ushort  offs;
 339 };
 340
 341 typedef struct Frame Frame;
 342 struct Frame {
 343         ulong   *fstart;
 344         ulong   *fjmp;
 345         uchar   *fbase;
 346 };
 347
 348 typedef struct Tv Tv;
 349 struct Tv {
 350         Lock;
 351         Rendez;
 352         Bt848   *bt848;
 353         Bt848   *bt878;         /* Really only audio control registers */
 354         Variant *variant;
 355         Tuner   *tuner;
 356         Pcidev  *pci;
 357         uchar   i2ctuneraddr;
 358         uchar   i2ccmd;         /* I2C command */
 359         int     board;          /* What board is this? */
 360         ulong   cfmt;           /* Current color format. */
 361         int     channel;        /* Current channel */
 362         Ref     fref;           /* Copying images? */
 363         int     nframes;        /* Number of frames to capture. */
 364         Frame   *frames;        /* DMA program */
 365         int     lvframe;        /* Last video frame DMAed */
 366         uchar   *amux;          /* Audio multiplexer. */
 367         int     nablocks;       /* Number of audio blocks allocated */
 368         int     absize;         /* Audio block size */
 369         int     narblocks;      /* Number of audio blocks received */
 370         ulong   *arisc;         /* Audio risc bloc */
 371         uchar   *abuf;          /* Audio data buffers */
 372         char    ainfo[128];
 373
 374         /* WinTV/PVR stuff. */
 375         int     msp;
 376         Lock    kfirlock;
 377         ulong   i2cstate;       /* Last i2c state. */
 378         int     gpiostate;      /* Current GPIO state */
 379         ulong   alterareg;      /* Last used altera register */
 380         ulong   alteraclock;    /* Used to clock the altera */
 381         int     asrate;         /* Audio sample rate */
 382         uchar   aleft, aright;  /* Left and right audio volume */
 383         ulong   kfirclock;
 384         Ref     aref;           /* Copying audio? */
 385 };
 386
 387 enum {
 388         TemicPAL = 0,
 389         PhilipsPAL,
 390         PhilipsNTSC,
 391         PhilipsSECAM,
 392         Notuner,
 393         PhilipsPALI,
 394         TemicNTSC,
 395         TemicPALI,
 396         Temic4036,
 397         AlpsTSBH1,
 398         AlpsTSBE1,
 399
 400         Freqmultiplier = 16,
 401 };
 402
 403 static Tuner tuners[] = {
 404         {"Temic PAL", Freqmultiplier * 140.25, Freqmultiplier * 463.25,
 405                 0x02, 0x04, 0x01, 0x8e, 623 },
 406         {"Philips PAL_I", Freqmultiplier * 140.25, Freqmultiplier * 463.25,
 407                 0xa0, 0x90, 0x30, 0x8e, 623 },
 408         {"Philips NTSC",  Freqmultiplier * 157.25, Freqmultiplier * 451.25,
 409                 0xA0, 0x90, 0x30, 0x8e, 732 },
 410         {"Philips SECAM", Freqmultiplier * 168.25, Freqmultiplier * 447.25,
 411                 0xA7, 0x97, 0x37, 0x8e, 623 },
 412         {"NoTuner", 0, 0,
 413                 0x00, 0x00, 0x00, 0x00, 0 },
 414         {"Philips PAL", Freqmultiplier * 168.25, Freqmultiplier * 447.25,
 415                 0xA0, 0x90, 0x30, 0x8e, 623 },
 416         {"Temic NTSC", Freqmultiplier * 157.25, Freqmultiplier * 463.25,
 417                 0x02, 0x04, 0x01, 0x8e, 732 },
 418         {"TEMIC PAL_I", Freqmultiplier * 170.00, Freqmultiplier * 450.00,
 419                 0x02, 0x04, 0x01, 0x8e, 623 },
 420         {"Temic 4036 FY5 NTSC", Freqmultiplier * 157.25, Freqmultiplier * 463.25,
 421                 0xa0, 0x90, 0x30, 0x8e, 732 },
 422         {"Alps TSBH1", Freqmultiplier * 137.25, Freqmultiplier * 385.25,
 423                 0x01, 0x02, 0x08, 0x8e, 732 },
 424         {"Alps TSBE1", Freqmultiplier * 137.25, Freqmultiplier * 385.25,
 425                 0x01, 0x02, 0x08, 0x8e, 732 },
 426 };
 427
 428 static int hp_tuners[] = {
 429         Notuner,
 430         Notuner,
 431         Notuner,
 432         Notuner,
 433         Notuner,
 434         PhilipsNTSC,
 435         Notuner,
 436         Notuner,
 437         PhilipsPAL,
 438         PhilipsSECAM,
 439         PhilipsNTSC,
 440         PhilipsPALI,
 441         Notuner,
 442         Notuner,
 443         TemicPAL,
 444         TemicPALI,
 445         Notuner,
 446         PhilipsSECAM,
 447         PhilipsNTSC,
 448         PhilipsPALI,
 449         Notuner,
 450         PhilipsPAL,
 451         Notuner,
 452         PhilipsNTSC,
 453 };
 454
 455 enum {
 456         CMvstart,
 457         CMastart,
 458         CMastop,
 459         CMvgastart,
 460         CMvstop,
 461         CMchannel,
 462         CMcolormode,
 463         CMvolume,
 464         CMmute,
 465 };
 466
 467 static Cmdtab tvctlmsg[] = {
 468         CMvstart,       "vstart",       2,
 469         CMastart,       "astart",       5,
 470         CMastop,        "astop",        1,
 471         CMvgastart,     "vgastart",     3,
 472         CMvstop,        "vstop",        1,
 473         CMchannel,      "channel",      3,
 474         CMcolormode,    "colormode",    2,
 475         CMvolume,       "volume",       3,
 476         CMmute,         "mute",         1,
 477 };
 478
 479 static Variant variant[] = {
 480         { Brooktree_vid, Brooktree_848_did, "Brooktree 848 TV tuner", },
 481         { Brooktree_vid, Brooktree_878_did, "Brooktree 878 TV tuner", },
 482 };
 483
 484 static char *boards[] = {
 485         "MIRO PRO",
 486         "MIRO",
 487         "Hauppauge Bt878",
 488 };
 489
 490 static ushort Adspfsample[] = {
 491         0x500, 0x700, 0x400, 0x600, 0x300, 0x200, 0x000, 0x100
 492 };
 493 static ushort Adspstereorates[] = {
 494         64, 96, 112, 128, 160, 192, 224, 256, 320, 384
 495 };
 496
 497 static uchar miroamux[] = { 2, 0, 0, 0, 10, 0 };
 498 static uchar hauppaugeamux[] = { 0, 1, 2, 3, 4, 0 };
 499 static char *nicamstate[] = {
 500         "analog", "???", "digital", "bad digital receiption"
 501 };
 502
 503
 504 static Tv tvs[Ntvs];
 505 static int ntvs;
 506
 507 static int i2cread(Tv *, uchar, uchar *);
 508 static int i2cwrite(Tv *, uchar, uchar, uchar, int);
 509 static void tvinterrupt(Ureg *, Tv *);
 510 static void vgastart(Tv *, ulong, int);
 511 static void vstart(Tv *, int, int, int, int);
 512 static void astart(Tv *, char *, uint, uint, uint);
 513 static void vstop(Tv *);
 514 static void astop(Tv *);
 515 static void colormode(Tv *, char *);
 516 static void frequency(Tv *, int, int);
 517 static int getbitspp(Tv *);
 518 static char *getcolormode(ulong);
 519 static int mspreset(Tv *);
 520 static void i2cscan(Tv *);
 521 static int kfirinitialize(Tv *);
 522 static void msptune(Tv *);
 523 static void mspvolume(Tv *, int, int, int);
 524 static void gpioenable(Tv *, ulong, ulong);
 525 static void gpiowrite(Tv *, ulong, ulong);
 526
 527 static void
 528 tvinit(void)
 529 {
 530         Pcidev *pci;
 531         ulong intmask;
 532
 533         /* Test for a triton memory controller. */
 534         intmask = 0;
 535         if (pcimatch(nil, Intel_vid, Intel_82437_did))
 536                 intmask = intmask_etbf;
 537
 538         pci = nil;
 539         while ((pci = pcimatch(pci, 0, 0)) != nil) {
 540                 int i, t;
 541                 Tv *tv;
 542                 Bt848 *bt848;
 543                 ushort hscale, hdelay;
 544                 uchar v;
 545
 546                 for (i = 0; i != nelem(variant); i++)
 547                         if (pci->vid == variant[i].vid && pci->did == variant[i].did)
 548                                 break;
 549                 if (i == nelem(variant))
 550                         continue;
 551
 552                 if (ntvs >= Ntvs) {
 553                         print("#V: Too many TV cards found\n");
 554                         continue;
 555                 }
 556
 557                 tv = &tvs[ntvs++];
 558                 tv->variant = &variant[i];
 559                 tv->pci = pci;
 560                 tv->bt848 = (Bt848 *)vmap(pci->mem[0].bar & ~0x0F, 4 * K);
 561                 if (tv->bt848 == nil)
 562                         panic("#V: Cannot allocate memory for Bt848");
 563                 bt848 = tv->bt848;
 564
 565                 /* i2c stuff. */
 566                 if (pci->did >= 878)
 567                         tv->i2ccmd = 0x83;
 568                 else
 569                         tv->i2ccmd = i2c_timing | i2c_bt848scl | i2c_bt848sda;
 570
 571                 t = 0;
 572                 if (i2cread(tv, i2c_haupee, &v)) {
 573                         uchar ee[256];
 574                         Pcidev *pci878;
 575                         Bt848 *bt878;
 576
 577                         tv->board = Bt878_hauppauge;
 578                         if (!i2cwrite(tv, i2c_haupee, 0, 0, 0))
 579                                 panic("#V: Cannot write to Hauppauge EEPROM");
 580                         for (i = 0; i != sizeof ee; i++)
 581                                 if (!i2cread(tv, i2c_haupee + 1, &ee[i]))
 582                                         panic("#V: Cannot read from Hauppauge EEPROM");
 583
 584                         if (ee[9] > sizeof hp_tuners / sizeof hp_tuners[0])
 585                                 panic("#V: Tuner out of range (max %d, this %d)",
 586                                         sizeof hp_tuners / sizeof hp_tuners[0], ee[9]);
 587                         t = hp_tuners[ee[9]];
 588
 589                         /* Initialize the audio channel. */
 590                         if ((pci878 = pcimatch(nil, Brooktree_vid, 0x878)) == nil)
 591                                 panic("#V: Unsupported Hauppage board");
 592
 593                         tv->bt878 = bt878 =
 594                                 (Bt848 *)vmap(pci878->mem[0].bar & ~0x0F, 4 * K);
 595                         if (bt878 == nil)
 596                                 panic("#V: Cannot allocate memory for the Bt878");
 597
 598                         kfirinitialize(tv);
 599                         // i2cscan(tv);
 600                         mspreset(tv);
 601
 602                         bt878->gpiodmactl = 0;
 603                         bt878->intstat = (ulong)-1;
 604                         intrenable(pci878->intl, (void (*)(Ureg *, void *))tvinterrupt,
 605                                         tv, pci878->tbdf, "tv");
 606
 607                         tv->amux = hauppaugeamux;
 608                 }
 609                 else if (i2cread(tv, i2c_stbee, &v)) {
 610                         USED(t);
 611                         panic("#V: Cannot deal with STB cards");
 612                 }
 613                 else if (i2cread(tv, i2c_miroproee, &v)) {
 614                         tv->board = Bt848_miropro;
 615                         t = ((bt848->gpiodata[0] >> 10) - 1) & 7;
 616                         tv->amux = miroamux;
 617                 }
 618                 else {
 619                         tv->board = Bt848_miro;
 620                         tv->amux = miroamux;
 621                         t = ((bt848->gpiodata[0] >> 10) - 1) & 7;
 622                 }
 623
 624                 if (t >= nelem(tuners))
 625                         t = 4;
 626                 tv->tuner = &tuners[t];
 627                 tv->i2ctuneraddr =
 628                         i2cread(tv, 0xc1, &v)? 0xc0:
 629                         i2cread(tv, 0xc3, &v)? 0xc2:
 630                         i2cread(tv, 0xc5, &v)? 0xc4:
 631                         i2cread(tv, 0xc7, &v)? 0xc6: -1;
 632
 633                 bt848->capctl = capctl_fullframe;
 634                 bt848->adelay = adelay_ntsc;
 635                 bt848->bdelay = bdelay_ntsc;
 636                 bt848->iform = iform_muxsel0|iform_xtauto|iform_ntsc;
 637                 bt848->vbipacksize = vbipacksize & 0xff;
 638                 bt848->vbipackdel = (vbipacksize >> 8) & 1;
 639
 640                 // setpll(bt848);
 641
 642                 tv->cfmt = bt848->colorfmt = colorfmt_rgb16;
 643
 644                 hscale = (ntsc_rawpixels * 4096) / ntsc_sqpixels - 4096;
 645                 hdelay = (ntsc_clkx1delay * ntsc_hactive) / ntsc_clkx1hactive;
 646
 647                 bt848->ovtc = bt848->evtc = 0;
 648                 bt848->ehscalehi = bt848->ohscalehi = (hscale >> 8) & 0xff;
 649                 bt848->ehscalelo = bt848->ohscalelo = hscale & 0xff;
 650                 bt848->evscalehi &= ~0x1f;
 651                 bt848->ovscalehi &= ~0x1f;
 652                 bt848->evscalehi |= vscale_interlaced | ((ntsc_vscale >> 8) & 0x1f);
 653                 bt848->ovscalehi |= vscale_interlaced | (ntsc_vscale >> 8) & 0x1f;
 654                 bt848->evscalelo = bt848->ovscalelo = ntsc_vscale & 0xff;
 655                 bt848->ehactivelo = bt848->ohactivelo = ntsc_hactive & 0xff;
 656                 bt848->ehdelaylo = bt848->ohdelaylo = hdelay & 0xff;
 657                 bt848->evactivelo = bt848->ovactivelo = ntsc_vactive & 0xff;
 658                 bt848->evdelaylo = bt848->ovdelaylo = ntsc_vdelay & 0xff;
 659                 bt848->ecrop = bt848->ocrop =
 660                         ((ntsc_hactive >> 8) & 0x03) |
 661                         ((hdelay >> 6) & 0x0C) |
 662                                 ((ntsc_vactive >> 4) & 0x30) |
 663                         ((ntsc_vdelay >> 2) & 0xC0);
 664
 665                 bt848->colorctl = colorctl_gamma;
 666                 bt848->capctl = 0;
 667                 bt848->gpiodmactl = gpiodmactl_pltp23_16 |
 668                         gpiodmactl_pltp1_16 | gpiodmactl_pktp_32;
 669                 bt848->gpioreginp = 0;
 670                 bt848->contrastlo = contrast_100percent;
 671                 bt848->bright = 16;
 672                 bt848->adc = (2 << 6) | adc_crush;
 673                 bt848->econtrol = bt848->ocontrol = control_ldec;
 674                 bt848->escloop = bt848->oscloop = 0;
 675                 bt848->intstat = (ulong)-1;
 676                 bt848->intmask = intmask |
 677                         intstat_vsync | intstat_scerr | intstat_risci | intstat_ocerr |
 678                         intstat_vpress | intstat_fmtchg;
 679
 680
 681                 if (tv->amux) {
 682                         gpioenable(tv, ~0xfff, 0xfff);
 683                         gpiowrite(tv, ~0xfff, tv->amux[AudioRadio]);
 684                 }
 685
 686                 print("#V%ld: %s (rev %d) (%s/%s) intl %d\n",
 687                         tv - tvs, tv->variant->name, pci->rid, boards[tv->board],
 688                         tv->tuner->name, pci->intl);
 689
 690                 intrenable(pci->intl, (void (*)(Ureg *, void *))tvinterrupt,
 691                         tv, pci->tbdf, "tv");
 692         }
 693 }
 694
 695 static Chan*
 696 tvattach(char *spec)
 697 {
 698         return devattach('V', spec);
 699 }
 700
 701 #define TYPE(q)         ((int)((q).path & 0xff))
 702 #define DEV(q)          ((int)(((q).path >> 8) & 0xff))
 703 #define QID(d, t)       ((((d) & 0xff) << 8) | (t))
 704
 705 static int
 706 tv1gen(Chan *c, int i, Dir *dp)
 707 {
 708         Qid qid;
 709
 710         switch (i) {
 711         case Qvdata:
 712                 mkqid(&qid, QID(DEV(c->qid), Qvdata), 0, QTFILE);
 713                 devdir(c, qid, "video", 0, eve, 0444, dp);
 714                 return 1;
 715         case Qadata:
 716                 mkqid(&qid, QID(DEV(c->qid), Qadata), 0, QTFILE);
 717                 devdir(c, qid, "audio", 0, eve, 0444, dp);
 718                 return 1;
 719         case Qctl:
 720                 mkqid(&qid, QID(DEV(c->qid), Qctl), 0, QTFILE);
 721                 devdir(c, qid, "ctl", 0, eve, 0444, dp);
 722                 return 1;
 723         case Qregs:
 724                 mkqid(&qid, QID(DEV(c->qid), Qregs), 0, QTFILE);
 725                 devdir(c, qid, "regs", 0, eve, 0444, dp);
 726                 return 1;
 727         }
 728         return -1;
 729 }
 730
 731 static int
 732 tvgen(Chan *c, char *, Dirtab *, int, int i, Dir *dp)
 733 {
 734         Qid qid;
 735         int dev;
 736
 737         dev = DEV(c->qid);
 738         switch (TYPE(c->qid)) {
 739         case Qdir:
 740                 if (i == DEVDOTDOT) {
 741                         mkqid(&qid, Qdir, 0, QTDIR);
 742                         devdir(c, qid, "#V", 0, eve, 0555, dp);
 743                         return 1;
 744                 }
 745
 746                 if (i >= ntvs)
 747                         return -1;
 748
 749                 mkqid(&qid, QID(i, Qsubdir), 0, QTDIR);
 750                 snprint(up->genbuf, sizeof(up->genbuf), "tv%d", i);
 751                 devdir(c, qid, up->genbuf, 0, eve, 0555, dp);
 752                 return 1;
 753
 754         case Qsubdir:
 755                 if (i == DEVDOTDOT) {
 756                         mkqid(&qid, QID(dev, Qdir), 0, QTDIR);
 757                         snprint(up->genbuf, sizeof(up->genbuf), "tv%d", dev);
 758                         devdir(c, qid, up->genbuf, 0, eve, 0555, dp);
 759                         return 1;
 760                 }
 761
 762                 return tv1gen(c, i + Qsubbase, dp);
 763
 764         case Qvdata:
 765         case Qadata:
 766         case Qctl:
 767         case Qregs:
 768                 return tv1gen(c, TYPE(c->qid), dp);
 769
 770         default:
 771                 return -1;
 772         }
 773 }
 774
 775 static Walkqid *
 776 tvwalk(Chan *c, Chan *nc, char **name, int nname)
 777 {
 778         return devwalk(c, nc, name, nname, 0, 0, tvgen);
 779 }
 780
 781 static int
 782 tvstat(Chan *c, uchar *db, int n)
 783 {
 784         return devstat(c, db, n, 0, 0, tvgen);
 785 }
 786
 787 static Chan*
 788 tvopen(Chan *c, int omode)
 789 {
 790         if (omode != OREAD &&
 791                 TYPE(c->qid) != Qctl && TYPE(c->qid) != Qvdata)
 792                 error(Eperm);
 793
 794         switch (TYPE(c->qid)) {
 795         case Qdir:
 796                 return devopen(c, omode, nil, 0, tvgen);
 797         case Qadata:
 798                 if (tvs[DEV(c->qid)].bt878 == nil)
 799                         error(Enonexist);
 800                 break;
 801         }
 802
 803         c->mode = openmode(omode);
 804         c->flag |= COPEN;
 805         c->offset = 0;
 806
 807         if (TYPE(c->qid) == Qadata)
 808                 c->aux = nil;
 809         return c;
 810 }
 811
 812 static void
 813 tvclose(Chan *)
 814 {
 815 }
 816
 817 static int
 818 audioblock(void *)
 819 {
 820         return 1;
 821 }
 822
 823 static long
 824 tvread(Chan *c, void *a, long n, vlong offset)
 825 {
 826         static char regs[10 * K];
 827         static int regslen;
 828         Tv *tv;
 829         char *e, *p;
 830         uchar *src;
 831
 832         USED(offset);
 833
 834         switch(TYPE(c->qid)) {
 835         case Qdir:
 836         case Qsubdir:
 837                 return devdirread(c, a, n, 0, 0, tvgen);
 838
 839         case Qvdata: {
 840                 int bpf, nb;
 841
 842                 tv = &tvs[DEV(c->qid)];
 843                 bpf = ntsc_hactive * ntsc_vactive * getbitspp(tv) / 8;
 844
 845                 if (offset >= bpf)
 846                         return 0;
 847
 848                 nb = n;
 849                 if (offset + nb > bpf)
 850                         nb = bpf - offset;
 851
 852                 ilock(tv);
 853                 if (tv->frames == nil || tv->lvframe >= tv->nframes ||
 854                         tv->frames[tv->lvframe].fbase == nil) {
 855                         iunlock(tv);
 856                         return 0;
 857                 }
 858
 859                 src = tv->frames[tv->lvframe].fbase;
 860                 incref(&tv->fref);
 861                 iunlock(tv);
 862
 863                 memmove(a, src + offset, nb);
 864                 decref(&tv->fref);
 865                 return nb;
 866         }
 867
 868         case Qadata: {
 869                 ulong uablock = (ulong)c->aux, bnum, tvablock;
 870                 int boffs, nbytes;
 871
 872                 tv = &tvs[DEV(c->qid)];
 873                 if (tv->bt878 == nil)
 874                         error("#V: No audio device");
 875                 if (tv->absize == 0)
 876                         error("#V: audio not initialized");
 877
 878                 bnum = offset / tv->absize;
 879                 boffs = offset % tv->absize;
 880                 nbytes = tv->absize - boffs;
 881
 882                 incref(&tv->aref);
 883                 for (;;) {
 884                         tvablock = tv->narblocks;       /* Current tv block. */
 885
 886                         if (uablock == 0)
 887                                 uablock = tvablock - 1;
 888
 889                         if (tvablock >= uablock + bnum + tv->narblocks)
 890                                 uablock = tvablock - 1 - bnum;
 891
 892                         if (uablock + bnum == tvablock) {
 893                                 sleep(tv, audioblock, nil);
 894                                 continue;
 895                         }
 896                         break;
 897                 }
 898
 899                 print("uablock %ld, bnum %ld, boffs %d, nbytes %d, tvablock %ld\n",
 900                         uablock, bnum, boffs, nbytes, tvablock);
 901                 src = tv->abuf + ((uablock + bnum) % tv->nablocks) * tv->absize;
 902                 print("copying from %#p (abuf %#p), nbytes %d (block %ld.%ld)\n",
 903                         src + boffs, tv->abuf, nbytes, uablock, bnum);
 904
 905                 memmove(a, src + boffs, nbytes);
 906                 decref(&tv->aref);
 907
 908                 uablock += (boffs + nbytes) % tv->absize;
 909                 c->aux = (void*)uablock;
 910
 911                 return nbytes;
 912         }
 913
 914         case Qctl: {
 915                 char str[128];
 916
 917                 tv = &tvs[DEV(c->qid)];
 918                 snprint(str, sizeof str, "%dx%dx%d %s channel %d %s\n",
 919                         ntsc_hactive, ntsc_vactive, getbitspp(tv),
 920                         getcolormode(tv->cfmt), tv->channel, tv->ainfo);
 921                 return readstr(offset, a, strlen(str) + 1, str);
 922         }
 923
 924         case Qregs:
 925                 if (offset == 0) {
 926                         Bt848 *bt848;
 927                         int i;
 928
 929                         tv = &tvs[DEV(c->qid)];
 930                         bt848 = tv->bt848;
 931
 932                         e = regs + sizeof(regs);
 933                         p = regs;
 934                         for (i = 0; i < 0x300 >> 2; i++)
 935                                 p = seprint(p, e, "%.3X %.8ulX\n", i << 2,
 936                                         ((ulong *)bt848)[i]);
 937                         if (tv->bt878) {
 938                                 bt848 = tv->bt878;
 939
 940                                 for (i = 0; i < 0x300 >> 2; i++)
 941                                         p = seprint(p, e, "%.3X %.8ulX\n",
 942                                                 i << 2, ((ulong *)bt848)[i]);
 943                         }
 944
 945                         regslen = p - regs;
 946                 }
 947
 948                 if (offset >= regslen)
 949                         return 0;
 950                 if (offset + n > regslen)
 951                         n = regslen - offset;
 952
 953                 return readstr(offset, a, n, &regs[offset]);
 954
 955         default:
 956                 n = 0;
 957                 break;
 958         }
 959         return n;
 960 }
 961
 962 static long
 963 tvwrite(Chan *c, void *a, long n, vlong)
 964 {
 965         Cmdbuf *cb;
 966         Cmdtab *ct;
 967         Tv *tv;
 968
 969         tv = &tvs[DEV(c->qid)];
 970         switch(TYPE(c->qid)) {
 971         case Qctl:
 972                 cb = parsecmd(a, n);
 973                 if(waserror()){
 974                         free(cb);
 975                         nexterror();
 976                 }
 977                 ct = lookupcmd(cb, tvctlmsg, nelem(tvctlmsg));
 978                 switch (ct->index) {
 979                 case CMvstart:
 980                         vstart(tv, (int)strtol(cb->f[1], (char **)nil, 0),
 981                                 ntsc_hactive, ntsc_vactive, ntsc_hactive);
 982                         break;
 983
 984                 case CMastart:
 985                         astart(tv, cb->f[1], (uint)strtol(cb->f[2], (char **)nil, 0),
 986                                 (uint)strtol(cb->f[3], (char **)nil, 0),
 987                                 (uint)strtol(cb->f[4], (char **)nil, 0));
 988                         break;
 989
 990                 case CMastop:
 991                         astop(tv);
 992                         break;
 993
 994                 case CMvgastart:
 995                         vgastart(tv, strtoul(cb->f[1], (char **)nil, 0),
 996                                 (int)strtoul(cb->f[2], (char **)nil, 0));
 997                         break;
 998
 999                 case CMvstop:
1000                         vstop(tv);
1001                         break;
1002
1003                 case CMchannel:
1004                         frequency(tv, (int)strtol(cb->f[1], (char **)nil, 0),
1005                                 (int)strtol(cb->f[2], (char **)nil, 0));
1006                         break;
1007
1008                 case CMcolormode:
1009                         colormode(tv, cb->f[1]);
1010                         break;
1011
1012                 case CMvolume:
1013                         if (!tv->msp)
1014                                 error("#V: No volume control");
1015
1016                         mspvolume(tv, 0, (int)strtol(cb->f[1], (char **)nil, 0),
1017                                 (int)strtol(cb->f[2], (char **)nil, 0));
1018                         break;
1019
1020                 case CMmute:
1021                         if (!tv->msp)
1022                                 error("#V: No volume control");
1023
1024                         mspvolume(tv, 1, 0, 0);
1025                         break;
1026                 }
1027                 poperror();
1028                 free(cb);
1029                 break;
1030
1031         default:
1032                 error(Eio);
1033         }
1034         return n;
1035 }
1036
1037 Dev tvdevtab = {
1038         'V',
1039         "tv",
1040
1041         devreset,
1042         tvinit,
1043         devshutdown,
1044         tvattach,
1045         tvwalk,
1046         tvstat,
1047         tvopen,
1048         devcreate,
1049         tvclose,
1050         tvread,
1051         devbread,
1052         tvwrite,
1053         devbwrite,
1054         devremove,
1055         devwstat,
1056 };
1057
1058 static void
1059 tvinterrupt(Ureg *, Tv *tv)
1060 {
1061         Bt848 *bt848 = tv->bt848, *bt878 = tv->bt878;
1062
1063         for (;;) {
1064                 ulong vstat, astat;
1065                 uchar fnum;
1066
1067                 vstat = bt848->intstat;
1068                 fnum = (vstat >> intstat_riscstatshift) & 0xf;
1069                 vstat &= bt848->intmask;
1070
1071                 if (bt878)
1072                         astat = bt878->intstat & bt878->intmask;
1073                 else
1074                         astat = 0;
1075
1076                 if (vstat == 0 && astat == 0)
1077                         break;
1078
1079                 if (astat)
1080                         print("vstat %.8luX, astat %.8luX\n", vstat, astat);
1081
1082                 bt848->intstat = vstat;
1083                 if (bt878)
1084                         bt878->intstat = astat;
1085
1086                 if ((vstat & intstat_fmtchg) == intstat_fmtchg) {
1087                         iprint("int: fmtchg\n");
1088                         vstat &= ~intstat_fmtchg;
1089                 }
1090
1091                 if ((vstat & intstat_vpress) == intstat_vpress) {
1092 //                      iprint("int: vpress\n");
1093                         vstat &= ~intstat_vpress;
1094                 }
1095
1096                 if ((vstat & intstat_vsync) == intstat_vsync)
1097                         vstat &= ~intstat_vsync;
1098
1099                 if ((vstat & intstat_scerr) == intstat_scerr) {
1100                         iprint("int: scerr\n");
1101                         bt848->gpiodmactl &=
1102                                 ~(gpiodmactl_riscenable|gpiodmactl_fifoenable);
1103                         bt848->gpiodmactl |= gpiodmactl_fifoenable;
1104                         bt848->gpiodmactl |= gpiodmactl_riscenable;
1105                         vstat &= ~intstat_scerr;
1106                 }
1107
1108                 if ((vstat & intstat_risci) == intstat_risci) {
1109                         tv->lvframe = fnum;
1110                         vstat &= ~intstat_risci;
1111                 }
1112
1113                 if ((vstat & intstat_ocerr) == intstat_ocerr) {
1114                         iprint("int: ocerr\n");
1115                         vstat &= ~intstat_ocerr;
1116                 }
1117
1118                 if ((vstat & intstat_fbus) == intstat_fbus) {
1119                         iprint("int: fbus\n");
1120                         vstat &= ~intstat_fbus;
1121                 }
1122
1123                 if (vstat)
1124                         iprint("int: (v) ignored interrupts %.8ulX\n", vstat);
1125
1126                 if ((astat & intstat_risci) == intstat_risci) {
1127                         tv->narblocks++;
1128                         if ((tv->narblocks % 100) == 0)
1129                                 print("a");
1130                         wakeup(tv);
1131                         astat &= ~intstat_risci;
1132                 }
1133
1134                 if ((astat & intstat_fdsr) == intstat_fdsr) {
1135                         iprint("int: (a) fdsr\n");
1136                         bt848->gpiodmactl &=
1137                                 ~(gpiodmactl_acapenable |
1138                                         gpiodmactl_riscenable | gpiodmactl_fifoenable);
1139                         astat &= ~intstat_fdsr;
1140                 }
1141
1142                 if (astat)
1143                         iprint("int: (a) ignored interrupts %.8ulX\n", astat);
1144         }
1145 }
1146
1147 static int
1148 i2cread(Tv *tv, uchar off, uchar *v)
1149 {
1150         Bt848 *bt848 = tv->bt848;
1151         ulong intstat;
1152         int i;
1153
1154         bt848->intstat  = intstat_i2cdone;
1155         bt848->i2c = (off << 24) | tv->i2ccmd;
1156
1157         intstat = -1;
1158         for (i = 0; i != 1000; i++) {
1159                 if ((intstat = bt848->intstat) & intstat_i2cdone)
1160                         break;
1161                 microdelay(1000);
1162         }
1163
1164         if (i == 1000) {
1165                 print("i2cread: timeout\n");
1166                 return 0;
1167         }
1168
1169         if ((intstat & intstat_i2crack) == 0)
1170                 return 0;
1171
1172         *v = bt848->i2c >> 8;
1173         return 1;
1174 }
1175
1176 static int
1177 i2cwrite(Tv *tv, uchar addr, uchar sub, uchar data, int both)
1178 {
1179         Bt848 *bt848 = tv->bt848;
1180         ulong intstat, d;
1181         int i;
1182
1183         bt848->intstat  = intstat_i2cdone;
1184         d = (addr << 24) | (sub << 16) | tv->i2ccmd;
1185         if (both)
1186                 d |= (data << 8) | i2c_bt848w3b;
1187         bt848->i2c = d;
1188
1189         intstat = 0;
1190         for (i = 0; i != 1000; i++) {
1191                 if ((intstat = bt848->intstat) & intstat_i2cdone)
1192                         break;
1193                 microdelay(1000);
1194         }
1195
1196         if (i == i2c_timeout) {
1197                 print("i2cwrite: timeout\n");
1198                 return 0;
1199         }
1200
1201         if ((intstat & intstat_i2crack) == 0)
1202                 return 0;
1203
1204         return 1;
1205 }
1206
1207 static ulong *
1208 riscpacked(ulong pa, int fnum, int w, int h, int stride, ulong **lastjmp)
1209 {
1210         ulong *p, *pbase;
1211         int i;
1212
1213         pbase = p = (ulong *)malloc((h + 6) * 2 * sizeof(ulong));
1214         assert(p);
1215
1216         assert(w <= 0x7FF);
1217
1218         *p++ = riscsync | riscsync_resync | riscsync_vre;
1219         *p++ = 0;
1220
1221         *p++ = riscsync | riscsync_fm1;
1222         *p++ = 0;
1223
1224         for (i = 0; i != h / 2; i++) {
1225                 *p++ = riscwrite | w | riscwrite_sol | riscwrite_eol;
1226                 *p++ = pa + i * 2 * stride;
1227         }
1228
1229         *p++ = riscsync | riscsync_resync | riscsync_vro;
1230         *p++ = 0;
1231
1232         *p++ = riscsync | riscsync_fm1;
1233         *p++ = 0;
1234
1235         for (i = 0; i != h / 2; i++) {
1236                 *p++ = riscwrite | w | riscwrite_sol | riscwrite_eol;
1237                 *p++ = pa + (i * 2 + 1) * stride;
1238         }
1239
1240         /* reset status.  you really need two instructions ;-(. */
1241         *p++ = riscjmp | (0xf << risclabelshift_reset);
1242         *p++ = PADDR(p);
1243         *p++ = riscjmp | riscirq | (fnum << risclabelshift_set);
1244         *lastjmp = p;
1245
1246         return pbase;
1247 }
1248
1249 static ulong *
1250 riscplanar411(ulong pa, int fnum, int w, int h, ulong **lastjmp)
1251 {
1252         ulong *p, *pbase, Cw, Yw, Ch;
1253         uchar *Ybase, *Cbbase, *Crbase;
1254         int i, bitspp;
1255
1256         bitspp = 6;
1257         assert(w * bitspp / 8 <= 0x7FF);
1258         pbase = p = (ulong *)malloc((h + 6) * 5 * sizeof(ulong));
1259         assert(p);
1260
1261         Yw = w;
1262         Ybase = (uchar *)pa;
1263         Cw = w >> 1;
1264         Ch = h >> 1;
1265         Cbbase = Ybase + Yw * h;
1266         Crbase = Cbbase + Cw * Ch;
1267
1268         *p++ = riscsync | riscsync_resync | riscsync_vre;
1269         *p++ = 0;
1270
1271         *p++ = riscsync | riscsync_fm3;
1272         *p++ = 0;
1273
1274         for (i = 0; i != h / 2; i++) {
1275                 *p++ = riscwrite123 | Yw | riscwrite_sol | riscwrite_eol;
1276                 *p++ = (Cw << 16) | Cw;
1277                 *p++ = (ulong)(Ybase + i * 2 * Yw);
1278                 *p++ = (ulong)(Cbbase + i * Cw);        /* Do not interlace */
1279                 *p++ = (ulong)(Crbase + i * Cw);
1280         }
1281
1282         *p++ = riscsync | riscsync_resync | riscsync_vro;
1283         *p++ = 0;
1284
1285         *p++ = riscsync | riscsync_fm3;
1286         *p++ = 0;
1287
1288         for (i = 0; i != h / 2; i++) {
1289                 *p++ = riscwrite1s23 | Yw | riscwrite_sol | riscwrite_eol;
1290                 *p++ = (Cw << 16) | Cw;
1291                 *p++ = (ulong)(Ybase + (i * 2 + 1) * Yw);
1292         }
1293
1294         /* reset status.  you really need two instructions ;-(. */
1295         *p++ = riscjmp | (0xf << risclabelshift_reset);
1296         *p++ = PADDR(p);
1297         *p++ = riscjmp | riscirq | (fnum << risclabelshift_set);
1298         *lastjmp = p;
1299
1300         return pbase;
1301 }
1302
1303 static ulong *
1304 riscplanar422(ulong pa, int fnum, int w, int h, ulong **lastjmp)
1305 {
1306         ulong *p, *pbase, Cw, Yw;
1307         uchar *Ybase, *Cbbase, *Crbase;
1308         int i, bpp;
1309
1310         bpp = 2;
1311         assert(w * bpp <= 0x7FF);
1312         pbase = p = (ulong *)malloc((h + 6) * 5 * sizeof(ulong));
1313         assert(p);
1314
1315         Yw = w;
1316         Ybase = (uchar *)pa;
1317         Cw = w >> 1;
1318         Cbbase = Ybase + Yw * h;
1319         Crbase = Cbbase + Cw * h;
1320
1321         *p++ = riscsync | riscsync_resync | riscsync_vre;
1322         *p++ = 0;
1323
1324         *p++ = riscsync | riscsync_fm3;
1325         *p++ = 0;
1326
1327         for (i = 0; i != h / 2; i++) {
1328                 *p++ = riscwrite123 | Yw | riscwrite_sol | riscwrite_eol;
1329                 *p++ = (Cw << 16) | Cw;
1330                 *p++ = (ulong)(Ybase + i * 2 * Yw);
1331                 *p++ = (ulong)(Cbbase + i * 2 * Cw);
1332                 *p++ = (ulong)(Crbase + i * 2 * Cw);
1333         }
1334
1335         *p++ = riscsync | riscsync_resync | riscsync_vro;
1336         *p++ = 0;
1337
1338         *p++ = riscsync | riscsync_fm3;
1339         *p++ = 0;
1340
1341         for (i = 0; i != h / 2; i++) {
1342                 *p++ = riscwrite123 | Yw | riscwrite_sol | riscwrite_eol;
1343                 *p++ = (Cw << 16) | Cw;
1344                 *p++ = (ulong)(Ybase + (i * 2 + 1) * Yw);
1345                 *p++ = (ulong)(Cbbase + (i * 2 + 1) * Cw);
1346                 *p++ = (ulong)(Crbase + (i * 2 + 1) * Cw);
1347         }
1348
1349         /* reset status.  you really need two instructions ;-(. */
1350         *p++ = riscjmp | (0xf << risclabelshift_reset);
1351         *p++ = PADDR(p);
1352         *p++ = riscjmp | riscirq | (fnum << risclabelshift_set);
1353         *lastjmp = p;
1354
1355         return pbase;
1356 }
1357
1358 static ulong *
1359 riscaudio(ulong pa, int nblocks, int bsize)
1360 {
1361         ulong *p, *pbase;
1362         int i;
1363
1364         pbase = p = (ulong *)malloc((nblocks + 3) * 2 * sizeof(ulong));
1365         assert(p);
1366
1367         *p++ = riscsync|riscsync_fm1;
1368         *p++ = 0;
1369
1370         for (i = 0; i != nblocks; i++) {
1371                 *p++ = riscwrite | riscwrite_sol | riscwrite_eol | bsize | riscirq |
1372                         ((i & 0xf) << risclabelshift_set) |
1373                         ((~i & 0xf) << risclabelshift_reset);
1374                 *p++ = pa + i * bsize;
1375         }
1376
1377         *p++ = riscsync | riscsync_vro;
1378         *p++ = 0;
1379         *p++ = riscjmp;
1380         *p++ = PADDR(pbase);
1381         USED(p);
1382
1383         return pbase;
1384 }
1385
1386
1387 static void
1388 vactivate(Tv *tv, Frame *frames, int nframes)
1389 {
1390         Bt848 *bt848 = tv->bt848;
1391
1392         ilock(tv);
1393         if (tv->frames) {
1394                 iunlock(tv);
1395                 error(Einuse);
1396         }
1397         poperror();
1398
1399         tv->frames = frames;
1400         tv->nframes = nframes;
1401
1402         bt848->riscstrtadd = PADDR(tv->frames[0].fstart);
1403         bt848->capctl |= capctl_captureodd|capctl_captureeven;
1404         bt848->gpiodmactl |= gpiodmactl_fifoenable;
1405         bt848->gpiodmactl |= gpiodmactl_riscenable;
1406
1407         iunlock(tv);
1408 }
1409
1410 static void
1411 vstart(Tv *tv, int nframes, int w, int h, int stride)
1412 {
1413         Frame *frames;
1414         int bitspp, i, bpf;
1415
1416         if (nframes >= 0x10)
1417                 error(Ebadarg);
1418
1419         bitspp = getbitspp(tv);
1420         bpf = w * h * bitspp / 8;
1421
1422         /* Add one as a spare. */
1423         frames = (Frame *)malloc(nframes * sizeof(Frame));
1424         assert(frames);
1425         if (waserror()) {
1426                 for (i = 0; i != nframes; i++)
1427                         if (frames[i].fbase)
1428                                 free(frames[i].fbase);
1429                 free(frames);
1430                 nexterror();
1431         }
1432         memset(frames, 0, nframes * sizeof(Frame));
1433
1434         for (i = 0; i != nframes; i++) {
1435                 if ((frames[i].fbase = (uchar *)malloc(bpf)) == nil)
1436                         error(Enomem);
1437
1438                 switch (tv->cfmt) {
1439                 case colorfmt_YCbCr422:
1440                         frames[i].fstart = riscplanar422(PADDR(frames[i].fbase),                                i, w, h, &frames[i].fjmp);
1441                         break;
1442                 case colorfmt_YCbCr411:
1443                         frames[i].fstart = riscplanar411(PADDR(frames[i].fbase),
1444                                 i, w, h, &frames[i].fjmp);
1445                         break;
1446                 case colorfmt_rgb16:
1447                         frames[i].fstart = riscpacked(PADDR(frames[i].fbase), i,
1448                                 w * bitspp / 8, h, stride * bitspp / 8,
1449                                 &frames[i].fjmp);
1450                         break;
1451                 default:
1452                         panic("vstart: Unsupport colorformat");
1453                 }
1454         }
1455
1456         for (i = 0; i != nframes; i++)
1457                 *frames[i].fjmp = PADDR(i == nframes - 1? frames[0].fstart:
1458                         frames[i + 1].fstart);
1459
1460         vactivate(tv, frames, nframes);
1461 }
1462
1463 static void
1464 astart(Tv *tv, char *input, uint rate, uint nab, uint nasz)
1465 {
1466         Bt848 *bt878 = tv->bt878;
1467         ulong *arisc;
1468         int selector;
1469         uchar *abuf;
1470         int s, d;
1471
1472         if (bt878 == nil || tv->amux == nil)
1473                 error("#V: Card does not support audio");
1474
1475         selector = 0;
1476         if (!strcmp(input, "tv"))
1477                 selector = asel_tv;
1478         else if (!strcmp(input, "radio"))
1479                 selector = asel_radio;
1480         else if (!strcmp(input, "mic"))
1481                 selector = asel_mic;
1482         else if (!strcmp(input, "smxc"))
1483                 selector = asel_smxc;
1484         else
1485                 error("#V: Invalid input");
1486
1487         if (nasz > 0xfff)
1488                 error("#V: Audio block size too big (max 0xfff)");
1489
1490         abuf = (uchar *)malloc(nab * nasz * sizeof(uchar));
1491         assert(abuf);
1492         arisc = riscaudio(PADDR(abuf), nab, nasz);
1493
1494         ilock(tv);
1495         if (tv->arisc) {
1496                 iunlock(tv);
1497                 free(abuf);
1498                 free(arisc);
1499                 error(Einuse);
1500         }
1501
1502         tv->arisc = arisc;
1503         tv->abuf = abuf;
1504         tv->nablocks = nab;
1505         tv->absize = nasz;
1506
1507         bt878->riscstrtadd = PADDR(tv->arisc);
1508         bt878->packetlen = (nab << 16) | nasz;
1509         bt878->intmask = intstat_scerr | intstat_ocerr | intstat_risci |
1510                         intstat_pabort | intstat_riperr | intstat_pperr |
1511                         intstat_fdsr | intstat_ftrgt | intstat_fbus;
1512
1513         /* Assume analog, 16bpp */
1514         for (s = 0; s < 16; s++)
1515                 if (rate << s > Hwbase_ad * 4 / 15)
1516                         break;
1517         for (d = 15; d >= 4; d--)
1518                 if (rate << s < Hwbase_ad * 4 / d)
1519                         break;
1520
1521         print("astart: sampleshift %d, decimation %d\n", s, d);
1522
1523         tv->narblocks = 0;
1524         bt878->gpiodmactl = gpiodmactl_fifoenable |
1525                 gpiodmactl_riscenable | gpiodmactl_acapenable |
1526                 gpiodmactl_daes2 |              /* gpiodmactl_apwrdn | */
1527                 gpiodmactl_daiomda | d << 8 | 9 << 28 | selector << 24;
1528         print("dmactl %.8ulX\n", bt878->gpiodmactl);
1529         iunlock(tv);
1530 }
1531
1532 static void
1533 astop(Tv *tv)
1534 {
1535         Bt848 *bt878 = tv->bt878;
1536
1537         ilock(tv);
1538         if (tv->aref.ref > 0) {
1539                 iunlock(tv);
1540                 error(Einuse);
1541         }
1542
1543         if (tv->abuf) {
1544                 bt878->gpiodmactl &= ~gpiodmactl_riscenable;
1545                 bt878->gpiodmactl &= ~gpiodmactl_fifoenable;
1546
1547                 free(tv->abuf);
1548                 tv->abuf = nil;
1549                 free(tv->arisc);
1550                 tv->arisc = nil;
1551         }
1552         iunlock(tv);
1553 }
1554
1555 static void
1556 vgastart(Tv *tv, ulong pa, int stride)
1557 {
1558         Frame *frame;
1559
1560         frame = (Frame *)malloc(sizeof(Frame));
1561         assert(frame);
1562         if (waserror()) {
1563                 free(frame);
1564                 nexterror();
1565         }
1566
1567         frame->fbase = nil;
1568         frame->fstart = riscpacked(pa, 0, ntsc_hactive * getbitspp(tv) / 8,
1569                 ntsc_vactive, stride * getbitspp(tv) / 8, &frame->fjmp);
1570         *frame->fjmp = PADDR(frame->fstart);
1571
1572         vactivate(tv, frame, 1);
1573 }
1574
1575 static void
1576 vstop(Tv *tv)
1577 {
1578         Bt848 *bt848 = tv->bt848;
1579
1580         ilock(tv);
1581         if (tv->fref.ref > 0) {
1582                 iunlock(tv);
1583                 error(Einuse);
1584         }
1585
1586         if (tv->frames) {
1587                 int i;
1588
1589                 bt848->gpiodmactl &= ~gpiodmactl_riscenable;
1590                 bt848->gpiodmactl &= ~gpiodmactl_fifoenable;
1591                 bt848->capctl &= ~(capctl_captureodd|capctl_captureeven);
1592
1593                 for (i = 0; i != tv->nframes; i++)
1594                         if (tv->frames[i].fbase)
1595                                 free(tv->frames[i].fbase);
1596                 free(tv->frames);
1597                 tv->frames = nil;
1598         }
1599         iunlock(tv);
1600 }
1601
1602 static long hrcfreq[] = {               /* HRC CATV frequencies */
1603             0,  7200,  5400,  6000,  6600,  7800,  8400, 17400,
1604         18000, 18600, 19200, 19800, 20400, 21000, 12000, 12600,
1605         13200, 13800, 14400, 15000, 15600, 16200, 16800, 21600,
1606         22200, 22800, 23400, 24000, 24600, 25200, 25800, 26400,
1607         27000, 27600, 28200, 28800, 29400, 30000, 30600, 31200,
1608         31800, 32400, 33000, 33600, 34200, 34800, 35400, 36000,
1609         36600, 37200, 37800, 38400, 39000, 39600, 40200, 40800,
1610         41400, 42000, 42600, 43200, 43800, 44400, 45000, 45600,
1611         46200, 46800, 47400, 48000, 48600, 49200, 49800, 50400,
1612         51000, 51600, 52200, 52800, 53400, 54000, 54600, 55200,
1613         55800, 56400, 57000, 57600, 58200, 58800, 59400, 60000,
1614         60600, 61200, 61800, 62400, 63000, 63600, 64200,  9000,
1615          9600, 10200, 10800, 11400, 64800, 65400, 66000, 66600,
1616         67200, 67800, 68400, 69000, 69600, 70200, 70800, 71400,
1617         72000, 72600, 73200, 73800, 74400, 75000, 75600, 76200,
1618         76800, 77400, 78000, 78600, 79200, 79800,
1619 };
1620
1621 static void
1622 frequency(Tv *tv, int channel, int finetune)
1623 {
1624         Tuner *tuner = tv->tuner;
1625         long freq;
1626         ushort div;
1627         uchar cfg;
1628
1629         if (channel < 0 || channel > nelem(hrcfreq))
1630                 error(Ebadarg);
1631
1632         freq = (hrcfreq[channel] * Freqmultiplier) / 100;
1633
1634         if (freq < tuner->freq_vhfh)
1635                 cfg = tuner->VHF_L;
1636         else if (freq < tuner->freq_uhf)
1637                 cfg = tuner->VHF_H;
1638         else
1639                 cfg = tuner->UHF;
1640
1641         div = (freq + tuner->offs + finetune) & 0x7fff;
1642
1643         if (!i2cwrite(tv, tv->i2ctuneraddr, (div >> 8) & 0x7f, div, 1))
1644                 error(Eio);
1645
1646         if (!i2cwrite(tv, tv->i2ctuneraddr, tuner->cfg, cfg, 1))
1647                 error(Eio);
1648
1649         tv->channel = channel;
1650         if (tv->msp)
1651                 msptune(tv);
1652 }
1653
1654 static struct {
1655         char    *cmode;
1656         ulong   realmode;
1657         ulong   cbits;
1658 } colormodes[] = {
1659         { "RGB16",      colorfmt_rgb16,         colorfmt_rgb16, },
1660         { "YCbCr422",   colorfmt_YCbCr422,      colorfmt_YCbCr422, },
1661         { "YCbCr411",   colorfmt_YCbCr411,      colorfmt_YCbCr422, },
1662 };
1663
1664 static void
1665 colormode(Tv *tv, char *colormode)
1666 {
1667         Bt848 *bt848 = tv->bt848;
1668         int i;
1669
1670         for (i = 0; i != nelem(colormodes); i++)
1671                 if (!strcmp(colormodes[i].cmode, colormode))
1672                         break;
1673
1674         if (i == nelem(colormodes))
1675                 error(Ebadarg);
1676
1677         tv->cfmt = colormodes[i].realmode;
1678         bt848->colorfmt = colormodes[i].cbits;
1679 }
1680
1681 static int
1682 getbitspp(Tv *tv)
1683 {
1684         switch (tv->cfmt) {
1685         case colorfmt_rgb16:
1686         case colorfmt_YCbCr422:
1687                 return 16;
1688         case colorfmt_YCbCr411:
1689                 return 12;
1690         default:
1691                 error("getbitspp: Unsupport color format\n");
1692         }
1693         return -1;
1694 }
1695
1696 static char *
1697 getcolormode(ulong cmode)
1698 {
1699         switch (cmode) {
1700         case colorfmt_rgb16:
1701                 return "RGB16";
1702         case colorfmt_YCbCr411:
1703                 return "YCbCr411";
1704         case colorfmt_YCbCr422:
1705                 return (cmode == colorfmt_YCbCr422)? "YCbCr422": "YCbCr411";
1706         default:
1707                 error("getcolormode: Unsupport color format\n");
1708         }
1709         return nil;
1710 }
1711
1712 static void
1713 i2c_set(Tv *tv, int scl, int sda)
1714 {
1715         Bt848 *bt848 = tv->bt848;
1716         ulong d;
1717
1718         bt848->i2c = (scl << 1) | sda;
1719         d = bt848->i2c;
1720         USED(d);
1721         microdelay(i2c_delay);
1722 }
1723
1724 static uchar
1725 i2c_getsda(Tv *tv)
1726 {
1727         Bt848 *bt848 = tv->bt848;
1728
1729         return bt848->i2c & i2c_sda;
1730 }
1731
1732 static void
1733 i2c_start(Tv *tv)
1734 {
1735         i2c_set(tv, 0, 1);
1736         i2c_set(tv, 1, 1);
1737         i2c_set(tv, 1, 0);
1738         i2c_set(tv, 0, 0);
1739 }
1740
1741 static void
1742 i2c_stop(Tv *tv)
1743 {
1744         i2c_set(tv, 0, 0);
1745         i2c_set(tv, 1, 0);
1746         i2c_set(tv, 1, 1);
1747 }
1748
1749 static void
1750 i2c_bit(Tv *tv, int sda)
1751 {
1752         i2c_set(tv, 0, sda);
1753         i2c_set(tv, 1, sda);
1754         i2c_set(tv, 0, sda);
1755 }
1756
1757 static int
1758 i2c_getack(Tv *tv)
1759 {
1760         int ack;
1761
1762         i2c_set(tv, 0, 1);
1763         i2c_set(tv, 1, 1);
1764         ack = i2c_getsda(tv);
1765         i2c_set(tv, 0, 1);
1766         return ack;
1767 }
1768
1769 static int
1770 i2c_wr8(Tv *tv, uchar d, int wait)
1771 {
1772         int i, ack;
1773
1774         i2c_set(tv, 0, 0);
1775         for (i = 0; i != 8; i++) {
1776                 i2c_bit(tv, (d & 0x80)? 1: 0);
1777                 d <<= 1;
1778         }
1779         if (wait)
1780                 microdelay(wait);
1781
1782         ack = i2c_getack(tv);
1783         return ack == 0;
1784 }
1785
1786 static uchar
1787 i2c_rd8(Tv *tv, int lastbyte)
1788 {
1789         int i;
1790         uchar d;
1791
1792         d = 0;
1793         i2c_set(tv, 0, 1);
1794         for (i = 0; i != 8; i++) {
1795                 i2c_set(tv, 1, 1);
1796                 d <<= 1;
1797                 if (i2c_getsda(tv))
1798                         d |= 1;
1799                 i2c_set(tv, 0, 1);
1800         }
1801
1802         i2c_bit(tv, lastbyte? 1: 0);
1803         return d;
1804 }
1805
1806 static int
1807 mspsend(Tv *tv, uchar *cmd, int ncmd)
1808 {
1809         int i, j, delay;
1810
1811         for (i = 0; i != 3; i++) {
1812                 delay = 2000;
1813
1814                 i2c_start(tv);
1815                 for (j = 0; j != ncmd; j++) {
1816                         if (!i2c_wr8(tv, cmd[j], delay))
1817                                 break;
1818                         delay = 0;
1819                 }
1820                 i2c_stop(tv);
1821
1822                 if (j == ncmd)
1823                         return 1;
1824
1825                 microdelay(10000);
1826                 print("mspsend: retrying\n");
1827         }
1828
1829         return 0;
1830 }
1831
1832 static int
1833 mspwrite(Tv *tv, uchar sub, ushort reg, ushort v)
1834 {
1835         uchar b[6];
1836
1837         b[0] = i2c_msp3400;
1838         b[1] = sub;
1839         b[2] = reg >> 8;
1840         b[3] = reg;
1841         b[4] = v >> 8;
1842         b[5] = v;
1843         return mspsend(tv, b, sizeof b);
1844 }
1845
1846 static int
1847 mspread(Tv *tv, uchar sub, ushort reg, ushort *data)
1848 {
1849         uchar b[4];
1850         int i;
1851
1852         b[0] = i2c_msp3400;
1853         b[1] = sub;
1854         b[2] = reg >> 8;
1855         b[3] = reg;
1856
1857         for (i = 0; i != 3; i++) {
1858                 i2c_start(tv);
1859                 if (!i2c_wr8(tv, b[0], 2000) ||
1860                         !i2c_wr8(tv, b[1] | 1, 0) ||
1861                         !i2c_wr8(tv, b[2], 0) ||
1862                         !i2c_wr8(tv, b[3], 0)) {
1863
1864                         i2c_stop(tv);
1865                         microdelay(10000);
1866                         print("retrying\n");
1867                         continue;
1868                 }
1869
1870                 i2c_start(tv);
1871
1872                 if (!i2c_wr8(tv, b[0] | 1, 2000)) {
1873                         i2c_stop(tv);
1874                         continue;
1875                 }
1876
1877                 *data  = i2c_rd8(tv, 0) << 8;
1878                 *data |= i2c_rd8(tv, 1);
1879                 i2c_stop(tv);
1880                 return 1;
1881         }
1882         return 0;
1883 }
1884
1885 static uchar mspt_reset[] = { i2c_msp3400, 0, 0x80, 0 };
1886 static uchar mspt_on[] = { i2c_msp3400, 0, 0, 0 };
1887
1888 static int
1889 mspreset(Tv *tv)
1890 {
1891         ushort v, p;
1892         Bt848 *bt848 = tv->bt848;
1893         ulong b;
1894
1895         b = 1 << 5;
1896         gpioenable(tv, ~b, b);
1897         gpiowrite(tv, ~b, 0);
1898         microdelay(2500);
1899         gpiowrite(tv, ~b, b);
1900
1901         bt848->i2c = 0x80;
1902
1903         microdelay(2000);
1904         mspsend(tv, mspt_reset, sizeof mspt_reset);
1905
1906         microdelay(2000);
1907         if (!mspsend(tv, mspt_on, sizeof mspt_on)) {
1908                 print("#V: Cannot find MSP34x5G on the I2C bus (on)\n");
1909                 return 0;
1910         }
1911         microdelay(2000);
1912
1913         if (!mspread(tv, msp_bbp, 0x001e, &v)) {
1914                 print("#V: Cannot read MSP34xG5 chip version\n");
1915                 return 0;
1916         }
1917
1918         if (!mspread(tv, msp_bbp, 0x001f, &p)) {
1919                 print("#V: Cannot read MSP34xG5 product code\n");
1920                 return 0;
1921         }
1922
1923         print("#V: MSP34%dg ROM %.d, %d.%d\n",
1924                 (uchar)(p >> 8), (uchar)p, (uchar)(v >> 8), (uchar)v);
1925
1926         tv->msp = 1;
1927         return 1;
1928 }
1929
1930 static void
1931 mspvolume(Tv *tv, int mute, int l, int r)
1932 {
1933         short v, d;
1934         ushort b;
1935
1936         if (mute) {
1937                 v = 0;
1938                 b = 0;
1939         }
1940         else {
1941                 tv->aleft = l;
1942                 tv->aright = r;
1943                 d = v = max(l, r);
1944                 if (d == 0)
1945                         d++;
1946                 b = ((r - l) * 0x7f) / d;
1947         }
1948
1949         mspwrite(tv, msp_bbp, 0, v << 8);
1950         mspwrite(tv, msp_bbp, 7, v? 0x4000: 0);
1951         mspwrite(tv, msp_bbp, 1, b << 8);
1952 }
1953
1954 static char *
1955 mspaformat(int f)
1956 {
1957         switch (f) {
1958         case 0:
1959                 return "unknown";
1960         case 2:
1961         case 0x20:
1962         case 0x30:
1963                 return "M-BTSC";
1964         case 3:
1965                 return "B/G-FM";
1966         case 4:
1967         case 9:
1968         case 0xB:
1969                 return "L-AM/NICAM D/Kn";
1970         case 8:
1971                 return "B/G-NICAM";
1972         case 0xA:
1973                 return "I";
1974         case 0x40:
1975                 return "FM-Radio";
1976         }
1977         return "unknown format";
1978 }
1979
1980
1981 static void
1982 msptune(Tv *tv)
1983 {
1984         ushort d, s, nicam;
1985         int i;
1986
1987         mspvolume(tv, 1, 0, 0);
1988         if (!mspwrite(tv, msp_dem, 0x0030, 0x2033))
1989                 error("#V: Cannot set MODUS register");
1990
1991         if (!mspwrite(tv, msp_bbp, 0x0008, 0x0320))
1992                 error("#V: Cannot set loadspeaker input");
1993
1994         if (!mspwrite(tv, msp_dem, 0x0040, 0x0001))
1995                 error("#V: Cannot set I2S clock freq");
1996         if (!mspwrite(tv, msp_bbp, 0x000d, 0x1900))
1997                 error("#V: Cannot set SCART prescale");
1998         if (!mspwrite(tv, msp_bbp, 0x000e, 0x2403))
1999                 error("#V: Cannot set FM/AM prescale");
2000         if (!mspwrite(tv, msp_bbp, 0x0010, 0x5a00))
2001                 error("#V: Cannot set NICAM prescale");
2002         if (!mspwrite(tv, msp_dem, 0x0020, 0x0001))
2003                 error("#V: Cannot start auto detect");
2004
2005         for (d = (ushort)-1, i = 0; i != 10; i++) {
2006                 if (!mspread(tv, msp_dem, 0x007e, &d))
2007                         error("#V: Cannot get autodetect info MSP34xG5");
2008
2009                 if (d == 0 || d < 0x800)
2010                         break;
2011                 delay(50);
2012         }
2013
2014         if (!mspread(tv, msp_dem, 0x0200, &s))
2015                 error("#V: Cannot get status info MSP34xG5");
2016
2017         mspvolume(tv, 0, tv->aleft, tv->aright);
2018
2019         nicam = ((s >> 4) & 2) | ((s >> 9) & 1);
2020         snprint(tv->ainfo, sizeof tv->ainfo, "%s %s %s",
2021                 mspaformat(d), (s & (1 << 6))? "stereo": "mono",
2022                 nicamstate[nicam]);
2023 }
2024
2025 static void
2026 i2cscan(Tv *tv)
2027 {
2028         int i, ack;
2029
2030         for (i = 0; i < 0x100; i += 2) {
2031                 i2c_start(tv);
2032                 ack = i2c_wr8(tv, i, 0);
2033                 i2c_stop(tv);
2034                 if (ack)
2035                         print("i2c device @%.2uX\n", i);
2036         }
2037
2038         for (i = 0xf0; i != 0xff; i++) {
2039                 i2c_start(tv);
2040                 ack = i2c_wr8(tv, i, 0);
2041                 i2c_stop(tv);
2042                 if (ack)
2043                         print("i2c device may be at @%.2uX\n", i);
2044         }
2045 }
2046
2047 static void
2048 gpioenable(Tv *tv, ulong mask, ulong data)
2049 {
2050         Bt848 *bt848 = tv->bt848;
2051
2052         bt848->gpioouten = (bt848->gpioouten & mask) | data;
2053 }
2054
2055 static void
2056 gpiowrite(Tv *tv, ulong mask, ulong data)
2057 {
2058         Bt848 *bt848 = tv->bt848;
2059
2060         bt848->gpiodata[0] = (bt848->gpiodata[0] & mask) | data;
2061 }
2062
2063 static void
2064 alteraoutput(Tv *tv)
2065 {
2066         if (tv->gpiostate == Gpiooutput)
2067                 return;
2068
2069         gpioenable(tv, ~0xffffff, 0x56ffff);
2070         microdelay(10);
2071         tv->gpiostate = Gpiooutput;
2072 }
2073
2074 static void
2075 alterainput(Tv *tv)
2076 {
2077         if (tv->gpiostate == Gpioinput)
2078                 return;
2079
2080         gpioenable(tv, ~0xffffff, 0x570000);
2081         microdelay(10);
2082         tv->gpiostate = Gpioinput;
2083 }
2084
2085 static void
2086 alterareg(Tv *tv, ulong reg)
2087 {
2088         if (tv->alterareg == reg)
2089                 return;
2090
2091         gpiowrite(tv, ~0x56ffff, (reg & 0x54ffff) | tv->alteraclock);
2092         microdelay(10);
2093         tv->alterareg = reg;
2094 }
2095
2096 static void
2097 alterawrite(Tv *tv, ulong reg, ushort data)
2098 {
2099         alteraoutput(tv);
2100         alterareg(tv, reg);
2101
2102         tv->alteraclock ^= 0x20000;
2103         gpiowrite(tv, ~0x56ffff, (reg & 0x540000) | data | tv->alteraclock);
2104         microdelay(10);
2105 }
2106
2107 static void
2108 alteraread(Tv *tv, int reg, ushort *data)
2109 {
2110         Bt848 *bt848 = tv->bt848;
2111
2112         if (tv->alterareg != reg) {
2113                 alteraoutput(tv);
2114                 alterareg(tv, reg);
2115         }
2116         else {
2117                 gpioenable(tv, ~0xffffff, 0x560000);
2118                 microdelay(10);
2119         }
2120
2121         alterainput(tv);
2122         gpiowrite(tv, ~0x570000, (reg & 0x560000) | tv->alteraclock);
2123         microdelay(10);
2124         *data = (ushort)bt848->gpiodata[0];
2125         microdelay(10);
2126 }
2127
2128 static void
2129 kfirloadu(Tv *tv, uchar *u, int ulen)
2130 {
2131         Bt848 *bt848 = tv->bt848;
2132         int i, j;
2133
2134         ilock(&tv->kfirlock);
2135         bt848->gpioouten &= 0xff000000;
2136         bt848->gpioouten |= gpio_altera_data |
2137                 gpio_altera_clock | gpio_altera_nconfig;
2138         bt848->gpiodata[0] &= 0xff000000;
2139         microdelay(10);
2140         bt848->gpiodata[0] |= gpio_altera_nconfig;
2141         microdelay(10);
2142
2143         /* Download the microcode */
2144         for (i = 0; i != ulen; i++)
2145                 for (j = 0; j != 8; j++) {
2146                         bt848->gpiodata[0] &= ~(gpio_altera_clock|gpio_altera_data);
2147                         if (u[i] & 1)
2148                                 bt848->gpiodata[0] |= gpio_altera_data;
2149                         bt848->gpiodata[0] |= gpio_altera_clock;
2150                         u[i] >>= 1;
2151                 }
2152         bt848->gpiodata[0] &= ~gpio_altera_clock;
2153         microdelay(100);
2154
2155         /* Initialize. */
2156         for (i = 0; i != 30; i++) {
2157                 bt848->gpiodata[0] &= ~gpio_altera_clock;
2158                 bt848->gpiodata[0] |= gpio_altera_clock;
2159         }
2160         bt848->gpiodata[0] &= ~(gpio_altera_clock|gpio_altera_data);
2161         iunlock(&tv->kfirlock);
2162
2163         tv->gpiostate = Gpioinit;
2164 }
2165
2166 static void
2167 kfirreset(Tv *tv)
2168 {
2169         alterawrite(tv, 0, 0);
2170         microdelay(10);
2171         alterawrite(tv, 0x40000, 0);
2172         microdelay(10);
2173         alterawrite(tv, 0x40006, 0x80);
2174         microdelay(10);
2175         alterawrite(tv, 8, 1);
2176         microdelay(10);
2177         alterawrite(tv, 0x40004, 2);
2178         microdelay(10);
2179         alterawrite(tv, 4, 3);
2180         microdelay(3);
2181 }
2182
2183 static int
2184 kfirinitialize(Tv *tv)
2185 {
2186         /* Initialize parameters? */
2187
2188         tv->gpiostate = Gpioinit;
2189         tv->alterareg = -1;
2190         tv->alteraclock = 0x20000;
2191         kfirloadu(tv, hcwAMC, sizeof hcwAMC);
2192         kfirreset(tv);
2193         return 1;
2194 }