sys/dev/video/bktr/bktr_core.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 /*-
  34  * 1. Redistributions of source code must retain the
  35  * Copyright (c) 1995 Mark Tinguely and Jim Lowe
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  * 3. All advertising materials mentioning features or use of this software
  47  *    must display the following acknowledgement:
  48  *      This product includes software developed by Mark Tinguely and Jim Lowe
  49  * 4. The name of the author may not be used to endorse or promote products
  50  *    derived from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  53  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  56  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  58  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  59  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  60  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  61  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  62  * POSSIBILITY OF SUCH DAMAGE.
  63  *
  64  * $FreeBSD: src/sys/dev/bktr/bktr_core.c,v 1.140 2005/12/04 10:06:03 ru Exp $
  65  */
  66
  67 /*
  68  * This is part of the Driver for Video Capture Cards (Frame grabbers)
  69  * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
  70  * chipset.
  71  * Copyright Roger Hardiman and Amancio Hasty.
  72  *
  73  * bktr_core : This deals with the Bt848/849/878/879 PCI Frame Grabber,
  74  *               Handles all the open, close, ioctl and read userland calls.
  75  *               Sets the Bt848 registers and generates RISC pograms.
  76  *               Controls the i2c bus and GPIO interface.
  77  *               Contains the interface to the kernel.
  78  *               (eg probe/attach and open/close/ioctl)
  79  */
  80
  81  /*
  82    The Brooktree BT848 Driver driver is based upon Mark Tinguely and
  83    Jim Lowe's driver for the Matrox Meteor PCI card . The
  84    Philips SAA 7116 and SAA 7196 are very different chipsets than
  85    the BT848.
  86
  87    The original copyright notice by Mark and Jim is included mostly
  88    to honor their fantastic work in the Matrox Meteor driver!
  89  */
  90
  91 #include "opt_bktr.h"           /* Include any kernel config options */
  92
  93 #include <sys/param.h>
  94 #include <sys/systm.h>
  95 #include <sys/kernel.h>
  96 #include <sys/lock.h>
  97 #include <sys/proc.h>
  98 #include <sys/signalvar.h>
  99 #include <sys/vnode.h>
 100 #include <sys/bus.h>            /* used by smbus and newbus */
 101 #include <sys/thread2.h>
 102
 103 #include <vm/vm.h>
 104 #include <vm/vm_kern.h>
 105 #include <vm/pmap.h>
 106 #include <vm/vm_extern.h>
 107
 108 #define PROC_LOCK(p)
 109 #define PROC_UNLOCK(p)
 110 #include <bus/pci/pcivar.h>
 111 #include "pcidevs.h"
 112
 113 #include <dev/video/meteor/ioctl_meteor.h>
 114 #include <dev/video/bktr/ioctl_bt848.h> /* extensions to ioctl_meteor.h */
 115 #include <dev/video/bktr/bktr_reg.h>
 116 #include <dev/video/bktr/bktr_tuner.h>
 117 #include <dev/video/bktr/bktr_card.h>
 118 #include <dev/video/bktr/bktr_audio.h>
 119 #include <dev/video/bktr/bktr_os.h>
 120 #include <dev/video/bktr/bktr_core.h>
 121 #if defined(BKTR_FREEBSD_MODULE)
 122 #include <dev/video/bktr/bktr_mem.h>
 123 #endif
 124
 125 #if defined(BKTR_USE_FREEBSD_SMBUS)
 126 #include <dev/video/bktr/bktr_i2c.h>
 127 #include <bus/smbus/smbconf.h>
 128 #include <bus/iicbus/iiconf.h>
 129 #include "smbus_if.h"
 130 #include "iicbus_if.h"
 131 #endif
 132
 133 const char *
 134 bktr_name(bktr_ptr_t bktr)
 135 {
 136   return bktr->bktr_xname;
 137 }
 138
 139 typedef u_char bool_t;
 140
 141 #define BKTRPRI PCATCH
 142 #define VBIPRI  PCATCH
 143
 144
 145 /*
 146  * memory allocated for DMA programs
 147  */
 148 #define DMA_PROG_ALLOC          (8 * PAGE_SIZE)
 149
 150 /* When to split a dma transfer , the bt848 has timing as well as
 151    dma transfer size limitations so that we have to split dma
 152    transfers into two dma requests
 153    */
 154 #define DMA_BT848_SPLIT 319*2
 155
 156 /*
 157  * Allocate enough memory for:
 158  *      768x576 RGB 16 or YUV (16 storage bits/pixel) = 884736 = 216 pages
 159  *
 160  * You may override this using the options "BROOKTREE_ALLOC_PAGES=value"
 161  * in your  kernel configuration file.
 162  */
 163
 164 #ifndef BROOKTREE_ALLOC_PAGES
 165 #define BROOKTREE_ALLOC_PAGES   217*4
 166 #endif
 167 #define BROOKTREE_ALLOC         (BROOKTREE_ALLOC_PAGES * PAGE_SIZE)
 168
 169 /* Definitions for VBI capture.
 170  * There are 16 VBI lines in a PAL video field (32 in a frame),
 171  * and we take 2044 samples from each line (placed in a 2048 byte buffer
 172  * for alignment).
 173  * VBI lines are held in a circular buffer before being read by a
 174  * user program from /dev/vbi.
 175  */
 176
 177 #define MAX_VBI_LINES         16   /* Maximum for all vidoe formats */
 178 #define VBI_LINE_SIZE         2048 /* Store upto 2048 bytes per line */
 179 #define VBI_BUFFER_ITEMS      20   /* Number of frames we buffer */
 180 #define VBI_DATA_SIZE         (VBI_LINE_SIZE * MAX_VBI_LINES * 2)
 181 #define VBI_BUFFER_SIZE       (VBI_DATA_SIZE * VBI_BUFFER_ITEMS)
 182
 183
 184 /*  Defines for fields  */
 185 #define ODD_F  0x01
 186 #define EVEN_F 0x02
 187
 188
 189 /*
 190  * Parameters describing size of transmitted image.
 191  */
 192
 193 static struct format_params format_params[] = {
 194 /* # define BT848_IFORM_F_AUTO             (0x0) - don't matter. */
 195   { 525, 26, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_AUTO,
 196     12,  1600 },
 197 /* # define BT848_IFORM_F_NTSCM            (0x1) */
 198   { 525, 26, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
 199     12, 1600 },
 200 /* # define BT848_IFORM_F_NTSCJ            (0x2) */
 201   { 525, 22, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
 202     12, 1600 },
 203 /* # define BT848_IFORM_F_PALBDGHI         (0x3) */
 204   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1,
 205     16,  2044 },
 206 /* # define BT848_IFORM_F_PALM             (0x4) */
 207   { 525, 22, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
 208     12, 1600 },
 209 /* # define BT848_IFORM_F_PALN             (0x5) */
 210   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1,
 211     16, 2044 },
 212 /* # define BT848_IFORM_F_SECAM            (0x6) */
 213   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0xa0, BT848_IFORM_X_XT1,
 214     16, 2044 },
 215 /* # define BT848_IFORM_F_RSVD             (0x7) - ???? */
 216   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT0,
 217     16, 2044 },
 218 };
 219
 220 /*
 221  * Table of supported Pixel Formats
 222  */
 223
 224 static struct meteor_pixfmt_internal {
 225         struct meteor_pixfmt public;
 226         u_int                color_fmt;
 227 } pixfmt_table[] = {
 228
 229 { { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,  0x03e0,  0x001f }, 0,0 }, 0x33 },
 230 { { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,  0x03e0,  0x001f }, 1,0 }, 0x33 },
 231
 232 { { 0, METEOR_PIXTYPE_RGB, 2, {   0xf800,  0x07e0,  0x001f }, 0,0 }, 0x22 },
 233 { { 0, METEOR_PIXTYPE_RGB, 2, {   0xf800,  0x07e0,  0x001f }, 1,0 }, 0x22 },
 234
 235 { { 0, METEOR_PIXTYPE_RGB, 3, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x11 },
 236
 237 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,0 }, 0x00 },
 238 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x00 },
 239 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x00 },
 240 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x00 },
 241 { { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 },
 242 { { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x44 },
 243 { { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 },
 244
 245 };
 246 #define PIXFMT_TABLE_SIZE NELEM(pixfmt_table)
 247
 248 /*
 249  * Table of Meteor-supported Pixel Formats (for SETGEO compatibility)
 250  */
 251
 252 /*  FIXME:  Also add YUV_422 and YUV_PACKED as well  */
 253 static struct {
 254         u_long               meteor_format;
 255         struct meteor_pixfmt public;
 256 } meteor_pixfmt_table[] = {
 257     { METEOR_GEO_YUV_12,
 258       { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }
 259     },
 260
 261       /* FIXME: Should byte swap flag be on for this one; negative in drvr? */
 262     { METEOR_GEO_YUV_422,
 263       { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }
 264     },
 265     { METEOR_GEO_YUV_PACKED,
 266       { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }
 267     },
 268     { METEOR_GEO_RGB16,
 269       { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,   0x03e0,   0x001f }, 0, 0 }
 270     },
 271     { METEOR_GEO_RGB24,
 272       { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000, 0x00ff00, 0x0000ff }, 0, 0 }
 273     },
 274
 275 };
 276 #define METEOR_PIXFMT_TABLE_SIZE NELEM(meteor_pixfmt_table)
 277
 278
 279 #define BSWAP (BT848_COLOR_CTL_BSWAP_ODD | BT848_COLOR_CTL_BSWAP_EVEN)
 280 #define WSWAP (BT848_COLOR_CTL_WSWAP_ODD | BT848_COLOR_CTL_WSWAP_EVEN)
 281
 282
 283
 284 /* sync detect threshold */
 285 #if 0
 286 #define SYNC_LEVEL              (BT848_ADC_RESERVED |   \
 287                                  BT848_ADC_CRUSH)       /* threshold ~125 mV */
 288 #else
 289 #define SYNC_LEVEL              (BT848_ADC_RESERVED |   \
 290                                  BT848_ADC_SYNC_T)      /* threshold ~75 mV */
 291 #endif
 292
 293
 294
 295
 296 /* debug utility for holding previous INT_STAT contents */
 297 #define STATUS_SUM
 298 static u_long   status_sum = 0;
 299
 300 /*
 301  * defines to make certain bit-fiddles understandable
 302  */
 303 #define FIFO_ENABLED            BT848_DMA_CTL_FIFO_EN
 304 #define RISC_ENABLED            BT848_DMA_CTL_RISC_EN
 305 #define FIFO_RISC_ENABLED       (BT848_DMA_CTL_FIFO_EN | BT848_DMA_CTL_RISC_EN)
 306 #define FIFO_RISC_DISABLED      0
 307
 308 #define ALL_INTS_DISABLED       0
 309 #define ALL_INTS_CLEARED        0xffffffff
 310 #define CAPTURE_OFF             0
 311
 312 #define BIT_SEVEN_HIGH          (1<<7)
 313 #define BIT_EIGHT_HIGH          (1<<8)
 314
 315 #define I2C_BITS                (BT848_INT_RACK | BT848_INT_I2CDONE)
 316 #define TDEC_BITS               (BT848_INT_FDSR | BT848_INT_FBUS)
 317
 318
 319
 320 static int              oformat_meteor_to_bt( u_long format );
 321
 322 static u_int            pixfmt_swap_flags( int pixfmt );
 323
 324 /*
 325  * bt848 RISC programming routines.
 326  */
 327 #ifdef BT848_DUMP
 328 static int      dump_bt848( bktr_ptr_t bktr );
 329 #endif
 330
 331 static void     yuvpack_prog( bktr_ptr_t bktr, char i_flag, int cols,
 332                               int rows,  int interlace );
 333 static void     yuv422_prog( bktr_ptr_t bktr, char i_flag, int cols,
 334                              int rows, int interlace );
 335 static void     yuv12_prog( bktr_ptr_t bktr, char i_flag, int cols,
 336                              int rows, int interlace );
 337 static void     rgb_prog( bktr_ptr_t bktr, char i_flag, int cols,
 338                           int rows, int interlace );
 339 static void     rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols,
 340                           int rows, int interlace );
 341 static void     build_dma_prog( bktr_ptr_t bktr, char i_flag );
 342
 343 static bool_t   getline(bktr_reg_t *, int);
 344 static bool_t   notclipped(bktr_reg_t * , int , int);
 345 static bool_t   split(bktr_reg_t *, volatile uint32_t **, int, u_long, int,
 346                       volatile u_char ** , int  );
 347
 348 static void     start_capture( bktr_ptr_t bktr, unsigned type );
 349 static void     set_fps( bktr_ptr_t bktr, u_short fps );
 350
 351
 352
 353 /*
 354  * Remote Control Functions
 355  */
 356 static void     remote_read(bktr_ptr_t bktr, struct bktr_remote *remote);
 357
 358
 359 /*
 360  * ioctls common to both video & tuner.
 361  */
 362 static int      common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg );
 363
 364
 365 #if !defined(BKTR_USE_FREEBSD_SMBUS)
 366 /*
 367  * i2c primitives for low level control of i2c bus. Added for MSP34xx control
 368  */
 369 static void     i2c_start( bktr_ptr_t bktr);
 370 static void     i2c_stop( bktr_ptr_t bktr);
 371 static int      i2c_write_byte( bktr_ptr_t bktr, unsigned char data);
 372 static int      i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last );
 373 #endif
 374
 375
 376
 377 /*
 378  * the common attach code, used by all OS versions.
 379  */
 380 void
 381 common_bktr_attach( bktr_ptr_t bktr, int unit, u_long pci_id, u_int rev )
 382 {
 383         vm_offset_t     buf = 0;
 384         int             need_to_allocate_memory = 1;
 385 #ifdef BKTR_NEW_MSP34XX_DRIVER
 386         int             err;
 387 #endif
 388
 389 /* If this is a module, check if there is any currently saved contiguous memory */
 390 #if defined(BKTR_FREEBSD_MODULE)
 391         if (bktr_has_stored_addresses(unit) == 1) {
 392                 /* recover the addresses */
 393                 bktr->dma_prog     = bktr_retrieve_address(unit, BKTR_MEM_DMA_PROG);
 394                 bktr->odd_dma_prog = bktr_retrieve_address(unit, BKTR_MEM_ODD_DMA_PROG);
 395                 bktr->vbidata      = bktr_retrieve_address(unit, BKTR_MEM_VBIDATA);
 396                 bktr->vbibuffer    = bktr_retrieve_address(unit, BKTR_MEM_VBIBUFFER);
 397                 buf                = bktr_retrieve_address(unit, BKTR_MEM_BUF);
 398                 need_to_allocate_memory = 0;
 399         }
 400 #endif
 401
 402         if (need_to_allocate_memory == 1) {
 403                 /* allocate space for dma program */
 404                 bktr->dma_prog     = get_bktr_mem(unit, DMA_PROG_ALLOC);
 405                 bktr->odd_dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC);
 406
 407                 /* allocte space for the VBI buffer */
 408                 bktr->vbidata  = get_bktr_mem(unit, VBI_DATA_SIZE);
 409                 bktr->vbibuffer = get_bktr_mem(unit, VBI_BUFFER_SIZE);
 410
 411                 /* allocate space for pixel buffer */
 412                 if ( BROOKTREE_ALLOC )
 413                         buf = get_bktr_mem(unit, BROOKTREE_ALLOC);
 414                 else
 415                         buf = 0;
 416         }
 417
 418 #ifdef USE_VBIMUTEX
 419         mtx_init(&bktr->vbimutex, "bktr vbi lock", NULL, MTX_DEF);
 420 #endif
 421
 422 /* If this is a module, save the current contiguous memory */
 423 #if defined(BKTR_FREEBSD_MODULE)
 424 bktr_store_address(unit, BKTR_MEM_DMA_PROG,     bktr->dma_prog);
 425 bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog);
 426 bktr_store_address(unit, BKTR_MEM_VBIDATA,      bktr->vbidata);
 427 bktr_store_address(unit, BKTR_MEM_VBIBUFFER,    bktr->vbibuffer);
 428 bktr_store_address(unit, BKTR_MEM_BUF,          buf);
 429 #endif
 430
 431
 432         if ( bootverbose ) {
 433                 kprintf("%s: buffer size %d, addr %p\n",
 434                         bktr_name(bktr), BROOKTREE_ALLOC,
 435                         (void *)(uintptr_t)vtophys(buf));
 436         }
 437
 438         if ( buf != 0 ) {
 439                 bktr->bigbuf = buf;
 440                 bktr->alloc_pages = BROOKTREE_ALLOC_PAGES;
 441                 bzero((caddr_t) bktr->bigbuf, BROOKTREE_ALLOC);
 442         } else {
 443                 bktr->alloc_pages = 0;
 444         }
 445
 446
 447         bktr->flags = METEOR_INITALIZED | METEOR_AUTOMODE |
 448                       METEOR_DEV0 | METEOR_RGB16;
 449         bktr->dma_prog_loaded = FALSE;
 450         bktr->cols = 640;
 451         bktr->rows = 480;
 452         bktr->frames = 1;               /* one frame */
 453         bktr->format = METEOR_GEO_RGB16;
 454         bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
 455         bktr->pixfmt_compat = TRUE;
 456
 457
 458         bktr->vbiinsert = 0;
 459         bktr->vbistart = 0;
 460         bktr->vbisize = 0;
 461         bktr->vbiflags = 0;
 462
 463
 464         /* using the pci device id and revision id */
 465         /* and determine the card type            */
 466         if (PCI_VENDOR(pci_id) == PCI_VENDOR_BROOKTREE)
 467         {
 468                 switch (PCI_PRODUCT(pci_id)) {
 469                 case PCI_PRODUCT_BROOKTREE_BT848:
 470                         if (rev == 0x12)
 471                                 bktr->id = BROOKTREE_848A;
 472                         else
 473                                 bktr->id = BROOKTREE_848;
 474                         break;
 475                 case PCI_PRODUCT_BROOKTREE_BT849:
 476                         bktr->id = BROOKTREE_849A;
 477                         break;
 478                 case PCI_PRODUCT_BROOKTREE_BT878:
 479                         bktr->id = BROOKTREE_878;
 480                         break;
 481                 case PCI_PRODUCT_BROOKTREE_BT879:
 482                         bktr->id = BROOKTREE_879;
 483                         break;
 484                 }
 485         }
 486
 487         bktr->clr_on_start = FALSE;
 488
 489         /* defaults for the tuner section of the card */
 490         bktr->tflags = TUNER_INITALIZED;
 491         bktr->tuner.frequency = 0;
 492         bktr->tuner.channel = 0;
 493         bktr->tuner.chnlset = DEFAULT_CHNLSET;
 494         bktr->tuner.afc = 0;
 495         bktr->tuner.radio_mode = 0;
 496         bktr->audio_mux_select = 0;
 497         bktr->audio_mute_state = FALSE;
 498         bktr->bt848_card = -1;
 499         bktr->bt848_tuner = -1;
 500         bktr->reverse_mute = -1;
 501         bktr->slow_msp_audio = 0;
 502         bktr->msp_use_mono_source = 0;
 503         bktr->msp_source_selected = -1;
 504         bktr->audio_mux_present = 1;
 505
 506 #ifdef BKTR_NEW_MSP34XX_DRIVER
 507         /* get hint on short programming of the msp34xx, so we know */
 508         /* if the decision what thread to start should be overwritten */
 509         if ( (err = resource_int_value("bktr", unit, "mspsimple",
 510                         &(bktr->mspsimple)) ) != 0 )
 511                 bktr->mspsimple = -1;   /* fall back to default */
 512 #endif
 513
 514         probeCard( bktr, TRUE, unit );
 515
 516         /* Initialise any MSP34xx or TDA98xx audio chips */
 517         init_audio_devices( bktr );
 518
 519 #ifdef BKTR_NEW_MSP34XX_DRIVER
 520         /* setup the kenrel thread */
 521         err = msp_attach( bktr );
 522         if ( err != 0 ) /* error doing kernel thread stuff, disable msp3400c */
 523                 bktr->card.msp3400c = 0;
 524 #endif
 525
 526
 527 }
 528
 529
 530 /* Copy the vbi lines from 'vbidata' into the circular buffer, 'vbibuffer'.
 531  * The circular buffer holds 'n' fixed size data blocks.
 532  * vbisize   is the number of bytes in the circular buffer
 533  * vbiread   is the point we reading data out of the circular buffer
 534  * vbiinsert is the point we insert data into the circular buffer
 535  */
 536 static void vbidecode(bktr_ptr_t bktr) {
 537         unsigned char *dest;
 538         unsigned int *seq_dest;
 539
 540         /* Check if there is room in the buffer to insert the data. */
 541         if (bktr->vbisize + VBI_DATA_SIZE > VBI_BUFFER_SIZE) return;
 542
 543         /* Copy the VBI data into the next free slot in the buffer. */
 544         /* 'dest' is the point in vbibuffer where we want to insert new data */
 545         dest = (unsigned char *)bktr->vbibuffer + bktr->vbiinsert;
 546         memcpy(dest, (unsigned char*)bktr->vbidata, VBI_DATA_SIZE);
 547
 548         /* Write the VBI sequence number to the end of the vbi data */
 549         /* This is used by the AleVT teletext program */
 550         seq_dest = (unsigned int *)((unsigned char *)bktr->vbibuffer
 551                         + bktr->vbiinsert
 552                         + (VBI_DATA_SIZE - sizeof(bktr->vbi_sequence_number)));
 553         *seq_dest = bktr->vbi_sequence_number;
 554
 555         /* And increase the VBI sequence number */
 556         /* This can wrap around */
 557         bktr->vbi_sequence_number++;
 558
 559
 560         /* Increment the vbiinsert pointer */
 561         /* This can wrap around */
 562         bktr->vbiinsert += VBI_DATA_SIZE;
 563         bktr->vbiinsert = (bktr->vbiinsert % VBI_BUFFER_SIZE);
 564
 565         /* And increase the amount of vbi data in the buffer */
 566         bktr->vbisize = bktr->vbisize + VBI_DATA_SIZE;
 567
 568 }
 569
 570
 571 /*
 572  * the common interrupt handler.
 573  * Returns a 0 or 1 depending on whether the interrupt has handled.
 574  * In the OS specific section, bktr_intr() is defined which calls this
 575  * common interrupt handler.
 576  */
 577 int
 578 common_bktr_intr( void *arg )
 579 {
 580         bktr_ptr_t              bktr;
 581         u_long                  bktr_status;
 582         u_char                  dstatus;
 583         u_long                  field;
 584         u_long                  w_field;
 585         u_long                  req_field;
 586
 587         bktr = (bktr_ptr_t) arg;
 588
 589         /*
 590          * check to see if any interrupts are unmasked on this device.  If
 591          * none are, then we likely got here by way of being on a PCI shared
 592          * interrupt dispatch list.
 593          */
 594         if (INL(bktr, BKTR_INT_MASK) == ALL_INTS_DISABLED)
 595                 return 0;       /* bail out now, before we do something we
 596                                    shouldn't */
 597
 598         if (!(bktr->flags & METEOR_OPEN)) {
 599                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
 600                 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
 601                 /* return; ?? */
 602         }
 603
 604         /* record and clear the INTerrupt status bits */
 605         bktr_status = INL(bktr, BKTR_INT_STAT);
 606         OUTL(bktr, BKTR_INT_STAT, bktr_status & ~I2C_BITS);     /* don't touch i2c */
 607
 608         /* record and clear the device status register */
 609         dstatus = INB(bktr, BKTR_DSTATUS);
 610         OUTB(bktr, BKTR_DSTATUS, 0x00);
 611
 612 #if defined( STATUS_SUM )
 613         /* add any new device status or INTerrupt status bits */
 614         status_sum |= (bktr_status & ~(BT848_INT_RSV0|BT848_INT_RSV1));
 615         status_sum |= ((dstatus & (BT848_DSTATUS_COF|BT848_DSTATUS_LOF)) << 6);
 616 #endif /* STATUS_SUM */
 617         /* kprintf( "%s: STATUS %x %x %x \n", bktr_name(bktr),
 618                 dstatus, bktr_status, INL(bktr, BKTR_RISC_COUNT) );
 619         */
 620
 621
 622         /* if risc was disabled re-start process again */
 623         /* if there was one of the following errors re-start again */
 624         if ( !(bktr_status & BT848_INT_RISC_EN) ||
 625              ((bktr_status &(/* BT848_INT_FBUS   | */
 626                              /* BT848_INT_FTRGT  | */
 627                              /* BT848_INT_FDSR   | */
 628                               BT848_INT_PPERR  |
 629                               BT848_INT_RIPERR | BT848_INT_PABORT |
 630                               BT848_INT_OCERR  | BT848_INT_SCERR) ) != 0)
 631                 || ((INB(bktr, BKTR_TDEC) == 0) && (bktr_status & TDEC_BITS)) ) {
 632
 633                 u_short tdec_save = INB(bktr, BKTR_TDEC);
 634
 635                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
 636                 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
 637
 638                 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
 639
 640                 /*  Reset temporal decimation counter  */
 641                 OUTB(bktr, BKTR_TDEC, 0);
 642                 OUTB(bktr, BKTR_TDEC, tdec_save);
 643
 644                 /*  Reset to no-fields captured state  */
 645                 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
 646                         switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
 647                         case METEOR_ONLY_ODD_FIELDS:
 648                                 bktr->flags |= METEOR_WANT_ODD;
 649                                 break;
 650                         case METEOR_ONLY_EVEN_FIELDS:
 651                                 bktr->flags |= METEOR_WANT_EVEN;
 652                                 break;
 653                         default:
 654                                 bktr->flags |= METEOR_WANT_MASK;
 655                                 break;
 656                         }
 657                 }
 658
 659                 OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
 660                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
 661                 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
 662
 663                 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
 664                                     BT848_INT_RISCI      |
 665                                     BT848_INT_VSYNC      |
 666                                     BT848_INT_FMTCHG);
 667
 668                 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
 669                 return 1;
 670         }
 671
 672         /* If this is not a RISC program interrupt, return */
 673         if (!(bktr_status & BT848_INT_RISCI))
 674                 return 0;
 675
 676 /**
 677         kprintf( "%s: intr status %x %x %x\n", bktr_name(bktr),
 678                 bktr_status, dstatus, INL(bktr, BKTR_RISC_COUNT) );
 679  */
 680
 681
 682         /*
 683          * Disable future interrupts if a capture mode is not selected.
 684          * This can happen when we are in the process of closing or
 685          * changing capture modes, otherwise it shouldn't happen.
 686          */
 687         if (!(bktr->flags & METEOR_CAP_MASK))
 688                 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
 689
 690
 691         /* Determine which field generated this interrupt */
 692         field = ( bktr_status & BT848_INT_FIELD ) ? EVEN_F : ODD_F;
 693
 694
 695         /*
 696          * Process the VBI data if it is being captured. We do this once
 697          * both Odd and Even VBI data is captured. Therefore we do this
 698          * in the Even field interrupt handler.
 699          */
 700         LOCK_VBI(bktr);
 701         if (  (bktr->vbiflags & VBI_CAPTURE)
 702             &&(bktr->vbiflags & VBI_OPEN)
 703             &&(field==EVEN_F)) {
 704                 /* Put VBI data into circular buffer */
 705                 vbidecode(bktr);
 706
 707                 /* If someone is blocked on reading from /dev/vbi, wake them */
 708                 if (bktr->vbi_read_blocked) {
 709                         bktr->vbi_read_blocked = FALSE;
 710                         wakeup(VBI_SLEEP);
 711                 }
 712
 713                 /* Inform anyone who is polling */
 714                 KNOTE(&bktr->vbi_kq.ki_note, 0);
 715
 716         }
 717         UNLOCK_VBI(bktr);
 718
 719         /*
 720          *  Register the completed field
 721          *    (For dual-field mode, require fields from the same frame)
 722          */
 723         switch ( bktr->flags & METEOR_WANT_MASK ) {
 724                 case METEOR_WANT_ODD  : w_field = ODD_F         ;  break;
 725                 case METEOR_WANT_EVEN : w_field = EVEN_F        ;  break;
 726                 default               : w_field = (ODD_F|EVEN_F);  break;
 727         }
 728         switch ( bktr->flags & METEOR_ONLY_FIELDS_MASK ) {
 729                 case METEOR_ONLY_ODD_FIELDS  : req_field = ODD_F  ;  break;
 730                 case METEOR_ONLY_EVEN_FIELDS : req_field = EVEN_F ;  break;
 731                 default                      : req_field = (ODD_F|EVEN_F);
 732                                                break;
 733         }
 734
 735         if (( field == EVEN_F ) && ( w_field == EVEN_F ))
 736                 bktr->flags &= ~METEOR_WANT_EVEN;
 737         else if (( field == ODD_F ) && ( req_field == ODD_F ) &&
 738                  ( w_field == ODD_F ))
 739                 bktr->flags &= ~METEOR_WANT_ODD;
 740         else if (( field == ODD_F ) && ( req_field == (ODD_F|EVEN_F) ) &&
 741                  ( w_field == (ODD_F|EVEN_F) ))
 742                 bktr->flags &= ~METEOR_WANT_ODD;
 743         else if (( field == ODD_F ) && ( req_field == (ODD_F|EVEN_F) ) &&
 744                  ( w_field == ODD_F )) {
 745                 bktr->flags &= ~METEOR_WANT_ODD;
 746                 bktr->flags |=  METEOR_WANT_EVEN;
 747         }
 748         else {
 749                 /*  We're out of sync.  Start over.  */
 750                 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
 751                         switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
 752                         case METEOR_ONLY_ODD_FIELDS:
 753                                 bktr->flags |= METEOR_WANT_ODD;
 754                                 break;
 755                         case METEOR_ONLY_EVEN_FIELDS:
 756                                 bktr->flags |= METEOR_WANT_EVEN;
 757                                 break;
 758                         default:
 759                                 bktr->flags |= METEOR_WANT_MASK;
 760                                 break;
 761                         }
 762                 }
 763                 return 1;
 764         }
 765
 766         /*
 767          * If we have a complete frame.
 768          */
 769         if (!(bktr->flags & METEOR_WANT_MASK)) {
 770                 bktr->frames_captured++;
 771                 /*
 772                  * post the completion time.
 773                  */
 774                 if (bktr->flags & METEOR_WANT_TS) {
 775                         struct timeval *ts;
 776
 777                         if ((u_int) bktr->alloc_pages * PAGE_SIZE
 778                            <= (bktr->frame_size + sizeof(struct timeval))) {
 779                                 ts =(struct timeval *)bktr->bigbuf +
 780                                   bktr->frame_size;
 781                                 /* doesn't work in synch mode except
 782                                  *  for first frame */
 783                                 /* XXX */
 784                                 microtime(ts);
 785                         }
 786                 }
 787
 788
 789                 /*
 790                  * Wake up the user in single capture mode.
 791                  */
 792                 if (bktr->flags & METEOR_SINGLE) {
 793
 794                         /* stop dma */
 795                         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
 796
 797                         /* disable risc, leave fifo running */
 798                         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
 799                         wakeup(BKTR_SLEEP);
 800                 }
 801
 802                 /*
 803                  * If the user requested to be notified via signal,
 804                  * let them know the frame is complete.
 805                  */
 806
 807                 if (bktr->proc != NULL) {
 808                         PROC_LOCK(bktr->proc);
 809                         ksignal( bktr->proc, bktr->signal);
 810                         PROC_UNLOCK(bktr->proc);
 811                 }
 812
 813                 /*
 814                  * Reset the want flags if in continuous or
 815                  * synchronous capture mode.
 816                  */
 817 /*
 818 * XXX NOTE (Luigi):
 819 * currently we only support 3 capture modes: odd only, even only,
 820 * odd+even interlaced (odd field first). A fourth mode (non interlaced,
 821 * either even OR odd) could provide 60 (50 for PAL) pictures per
 822 * second, but it would require this routine to toggle the desired frame
 823 * each time, and one more different DMA program for the Bt848.
 824 * As a consequence, this fourth mode is currently unsupported.
 825 */
 826
 827                 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
 828                         switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
 829                         case METEOR_ONLY_ODD_FIELDS:
 830                                 bktr->flags |= METEOR_WANT_ODD;
 831                                 break;
 832                         case METEOR_ONLY_EVEN_FIELDS:
 833                                 bktr->flags |= METEOR_WANT_EVEN;
 834                                 break;
 835                         default:
 836                                 bktr->flags |= METEOR_WANT_MASK;
 837                                 break;
 838                         }
 839                 }
 840         }
 841
 842         return 1;
 843 }
 844
 845
 846
 847
 848 /*
 849  *
 850  */
 851 extern int bt848_format; /* used to set the default format, PAL or NTSC */
 852 int
 853 video_open( bktr_ptr_t bktr )
 854 {
 855         int frame_rate, video_format=0;
 856
 857         if (bktr->flags & METEOR_OPEN)          /* device is busy */
 858                 return( EBUSY );
 859
 860         bktr->flags |= METEOR_OPEN;
 861
 862 #ifdef BT848_DUMP
 863         dump_bt848(bktr);
 864 #endif
 865
 866         bktr->clr_on_start = FALSE;
 867
 868         OUTB(bktr, BKTR_DSTATUS, 0x00);                 /* clear device status reg. */
 869
 870         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
 871
 872 #if defined(BKTR_SYSTEM_DEFAULT) && BKTR_SYSTEM_DEFAULT == BROOKTREE_PAL
 873         video_format = 0;
 874 #else
 875         video_format = 1;
 876 #endif
 877
 878         if (bt848_format == 0 )
 879           video_format = 0;
 880
 881         if (bt848_format == 1 )
 882           video_format = 1;
 883
 884         if (video_format == 1 ) {
 885           OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_NTSCM);
 886           bktr->format_params = BT848_IFORM_F_NTSCM;
 887
 888         } else {
 889           OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_PALBDGHI);
 890           bktr->format_params = BT848_IFORM_F_PALBDGHI;
 891
 892         }
 893
 894         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | format_params[bktr->format_params].iform_xtsel);
 895
 896         /* work around for new Hauppauge 878 cards */
 897         if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
 898             (bktr->id==BROOKTREE_878 || bktr->id==BROOKTREE_879) )
 899                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
 900         else
 901                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
 902
 903         OUTB(bktr, BKTR_ADELAY, format_params[bktr->format_params].adelay);
 904         OUTB(bktr, BKTR_BDELAY, format_params[bktr->format_params].bdelay);
 905         frame_rate    = format_params[bktr->format_params].frame_rate;
 906
 907         /* enable PLL mode using 28Mhz crystal for PAL/SECAM users */
 908         if (bktr->xtal_pll_mode == BT848_USE_PLL) {
 909                 OUTB(bktr, BKTR_TGCTRL, 0);
 910                 OUTB(bktr, BKTR_PLL_F_LO, 0xf9);
 911                 OUTB(bktr, BKTR_PLL_F_HI, 0xdc);
 912                 OUTB(bktr, BKTR_PLL_F_XCI, 0x8e);
 913         }
 914
 915         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) | METEOR_DEV0;
 916
 917         bktr->max_clip_node = 0;
 918
 919         OUTB(bktr, BKTR_COLOR_CTL, BT848_COLOR_CTL_GAMMA | BT848_COLOR_CTL_RGB_DED);
 920
 921         OUTB(bktr, BKTR_E_HSCALE_LO, 170);
 922         OUTB(bktr, BKTR_O_HSCALE_LO, 170);
 923
 924         OUTB(bktr, BKTR_E_DELAY_LO, 0x72);
 925         OUTB(bktr, BKTR_O_DELAY_LO, 0x72);
 926         OUTB(bktr, BKTR_E_SCLOOP, 0);
 927         OUTB(bktr, BKTR_O_SCLOOP, 0);
 928
 929         OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
 930         OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
 931
 932         bktr->fifo_errors = 0;
 933         bktr->dma_errors = 0;
 934         bktr->frames_captured = 0;
 935         bktr->even_fields_captured = 0;
 936         bktr->odd_fields_captured = 0;
 937         bktr->proc = NULL;
 938         set_fps(bktr, frame_rate);
 939         bktr->video.addr = 0;
 940         bktr->video.width = 0;
 941         bktr->video.banksize = 0;
 942         bktr->video.ramsize = 0;
 943         bktr->pixfmt_compat = TRUE;
 944         bktr->format = METEOR_GEO_RGB16;
 945         bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
 946
 947         bktr->capture_area_enabled = FALSE;
 948
 949         OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT);        /* if you take this out triton
 950                                                    based motherboards will
 951                                                    operate unreliably */
 952         return( 0 );
 953 }
 954
 955 int
 956 vbi_open( bktr_ptr_t bktr )
 957 {
 958
 959         LOCK_VBI(bktr);
 960
 961         if (bktr->vbiflags & VBI_OPEN) {        /* device is busy */
 962                 UNLOCK_VBI(bktr);
 963                 return( EBUSY );
 964         }
 965
 966         bktr->vbiflags |= VBI_OPEN;
 967
 968         /* reset the VBI circular buffer pointers and clear the buffers */
 969         bktr->vbiinsert = 0;
 970         bktr->vbistart = 0;
 971         bktr->vbisize = 0;
 972         bktr->vbi_sequence_number = 0;
 973         bktr->vbi_read_blocked = FALSE;
 974
 975         bzero((caddr_t) bktr->vbibuffer, VBI_BUFFER_SIZE);
 976         bzero((caddr_t) bktr->vbidata,  VBI_DATA_SIZE);
 977
 978         UNLOCK_VBI(bktr);
 979
 980         return( 0 );
 981 }
 982
 983 /*
 984  *
 985  */
 986 int
 987 tuner_open( bktr_ptr_t bktr )
 988 {
 989         if ( !(bktr->tflags & TUNER_INITALIZED) )       /* device not found */
 990                 return( ENXIO );
 991
 992         if ( bktr->tflags & TUNER_OPEN )                /* already open */
 993                 return( 0 );
 994
 995         bktr->tflags |= TUNER_OPEN;
 996         bktr->tuner.frequency = 0;
 997         bktr->tuner.channel = 0;
 998         bktr->tuner.chnlset = DEFAULT_CHNLSET;
 999         bktr->tuner.afc = 0;
1000         bktr->tuner.radio_mode = 0;
1001
1002         /* enable drivers on the GPIO port that control the MUXes */
1003         OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | bktr->card.gpio_mux_bits);
1004
1005         /* unmute the audio stream */
1006         set_audio( bktr, AUDIO_UNMUTE );
1007
1008         /* Initialise any audio chips, eg MSP34xx or TDA98xx */
1009         init_audio_devices( bktr );
1010
1011         return( 0 );
1012 }
1013
1014
1015
1016
1017 /*
1018  *
1019  */
1020 int
1021 video_close( bktr_ptr_t bktr )
1022 {
1023         bktr->flags &= ~(METEOR_OPEN     |
1024                          METEOR_SINGLE   |
1025                          METEOR_CAP_MASK |
1026                          METEOR_WANT_MASK);
1027
1028         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1029         OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
1030
1031         bktr->dma_prog_loaded = FALSE;
1032         OUTB(bktr, BKTR_TDEC, 0);
1033         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1034
1035 /** FIXME: is 0xf magic, wouldn't 0x00 work ??? */
1036         OUTL(bktr, BKTR_SRESET, 0xf);
1037         OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1038
1039         return( 0 );
1040 }
1041
1042
1043 /*
1044  * tuner close handle,
1045  *  place holder for tuner specific operations on a close.
1046  */
1047 int
1048 tuner_close( bktr_ptr_t bktr )
1049 {
1050         bktr->tflags &= ~TUNER_OPEN;
1051
1052         /* mute the audio by switching the mux */
1053         set_audio( bktr, AUDIO_MUTE );
1054
1055         /* disable drivers on the GPIO port that control the MUXes */
1056         OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) & ~bktr->card.gpio_mux_bits);
1057
1058         return( 0 );
1059 }
1060
1061 int
1062 vbi_close( bktr_ptr_t bktr )
1063 {
1064
1065         LOCK_VBI(bktr);
1066
1067         bktr->vbiflags &= ~VBI_OPEN;
1068
1069         UNLOCK_VBI(bktr);
1070
1071         return( 0 );
1072 }
1073
1074 /*
1075  *
1076  */
1077 int
1078 video_read(bktr_ptr_t bktr, int unit, cdev_t dev, struct uio *uio)
1079 {
1080         int             status;
1081         int             count;
1082
1083
1084         if (bktr->bigbuf == 0)  /* no frame buffer allocated (ioctl failed) */
1085                 return( ENOMEM );
1086
1087         if (bktr->flags & METEOR_CAP_MASK)
1088                 return( EIO );  /* already capturing */
1089
1090         OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1091
1092
1093         count = bktr->rows * bktr->cols *
1094                 pixfmt_table[ bktr->pixfmt ].public.Bpp;
1095
1096         if ((int) uio->uio_iov->iov_len < count)
1097                 return( EINVAL );
1098
1099         bktr->flags &= ~(METEOR_CAP_MASK | METEOR_WANT_MASK);
1100
1101         /* capture one frame */
1102         start_capture(bktr, METEOR_SINGLE);
1103         /* wait for capture to complete */
1104         OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1105         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1106         OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1107         OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1108                             BT848_INT_RISCI      |
1109                             BT848_INT_VSYNC      |
1110                             BT848_INT_FMTCHG);
1111
1112
1113         status = tsleep(BKTR_SLEEP, BKTRPRI, "captur", 0);
1114         if (!status)            /* successful capture */
1115                 status = uiomove((caddr_t)bktr->bigbuf, count, uio);
1116         else
1117                 kprintf ("%s: read: tsleep error %d\n",
1118                         bktr_name(bktr), status);
1119
1120         bktr->flags &= ~(METEOR_SINGLE | METEOR_WANT_MASK);
1121
1122         return( status );
1123 }
1124
1125 /*
1126  * Read VBI data from the vbi circular buffer
1127  * The buffer holds vbi data blocks which are the same size
1128  * vbiinsert is the position we will insert the next item into the buffer
1129  * vbistart is the actual position in the buffer we want to read from
1130  * vbisize is the exact number of bytes in the buffer left to read
1131  */
1132 int
1133 vbi_read(bktr_ptr_t bktr, struct uio *uio, int ioflag)
1134 {
1135         int             readsize, readsize2, start;
1136         int             status;
1137
1138         /*
1139          * XXX - vbi_read() should be protected against being re-entered
1140          * while it is unlocked for the uiomove.
1141          */
1142         LOCK_VBI(bktr);
1143
1144         while(bktr->vbisize == 0) {
1145                 if (ioflag & IO_NDELAY) {
1146                         status = EWOULDBLOCK;
1147                         goto out;
1148                 }
1149
1150                 bktr->vbi_read_blocked = TRUE;
1151 #ifdef USE_VBIMUTEX
1152                 if ((status = msleep(VBI_SLEEP, &bktr->vbimutex, VBIPRI, "vbi",
1153                     0))) {
1154                         goto out;
1155                 }
1156 #else
1157                 if ((status = tsleep(VBI_SLEEP, VBIPRI, "vbi", 0))) {
1158                         goto out;
1159                 }
1160 #endif
1161         }
1162
1163         /* Now we have some data to give to the user */
1164
1165         /* We cannot read more bytes than there are in
1166          * the circular buffer
1167          */
1168         readsize = (int)uio->uio_iov->iov_len;
1169
1170         if (readsize > bktr->vbisize) readsize = bktr->vbisize;
1171
1172         /* Check if we can read this number of bytes without having
1173          * to wrap around the circular buffer */
1174         if((bktr->vbistart + readsize) >= VBI_BUFFER_SIZE) {
1175                 /* We need to wrap around */
1176
1177                 readsize2 = VBI_BUFFER_SIZE - bktr->vbistart;
1178                 start =  bktr->vbistart;
1179                 UNLOCK_VBI(bktr);
1180                 status = uiomove((caddr_t)bktr->vbibuffer + start, readsize2, uio);
1181                 if (status == 0)
1182                         status = uiomove((caddr_t)bktr->vbibuffer, (readsize - readsize2), uio);
1183         } else {
1184                 UNLOCK_VBI(bktr);
1185                 /* We do not need to wrap around */
1186                 status = uiomove((caddr_t)bktr->vbibuffer + bktr->vbistart, readsize, uio);
1187         }
1188
1189         LOCK_VBI(bktr);
1190
1191         /* Update the number of bytes left to read */
1192         bktr->vbisize -= readsize;
1193
1194         /* Update vbistart */
1195         bktr->vbistart += readsize;
1196         bktr->vbistart = bktr->vbistart % VBI_BUFFER_SIZE; /* wrap around if needed */
1197
1198 out:
1199         UNLOCK_VBI(bktr);
1200
1201         return( status );
1202
1203 }
1204
1205
1206
1207 /*
1208  * video ioctls
1209  */
1210 int
1211 video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td )
1212 {
1213         volatile u_char         c_temp;
1214         unsigned int            temp;
1215         unsigned int            temp_iform;
1216         unsigned int            error;
1217         struct meteor_geomet    *geo;
1218         struct meteor_counts    *counts;
1219         struct meteor_video     *video;
1220         struct bktr_capture_area *cap_area;
1221         vm_offset_t             buf;
1222         int                     i;
1223         int                     sig;
1224         char                    char_temp;
1225
1226         switch ( cmd ) {
1227
1228         case BT848SCLIP: /* set clip region */
1229             bktr->max_clip_node = 0;
1230             memcpy(&bktr->clip_list, arg, sizeof(bktr->clip_list));
1231
1232             for (i = 0; i < BT848_MAX_CLIP_NODE; i++) {
1233                 if (bktr->clip_list[i].y_min ==  0 &&
1234                     bktr->clip_list[i].y_max == 0)
1235                     break;
1236             }
1237             bktr->max_clip_node = i;
1238
1239             /* make sure that the list contains a valid clip secquence */
1240             /* the clip rectangles should be sorted by x then by y as the
1241                second order sort key */
1242
1243             /* clip rectangle list is terminated by y_min and y_max set to 0 */
1244
1245             /* to disable clipping set  y_min and y_max to 0 in the first
1246                clip rectangle . The first clip rectangle is clip_list[0].
1247              */
1248
1249
1250
1251             if (bktr->max_clip_node == 0 &&
1252                 (bktr->clip_list[0].y_min != 0 &&
1253                  bktr->clip_list[0].y_max != 0)) {
1254                 return EINVAL;
1255             }
1256
1257             for (i = 0; i < BT848_MAX_CLIP_NODE - 1 ; i++) {
1258                 if (bktr->clip_list[i].y_min == 0 &&
1259                     bktr->clip_list[i].y_max == 0) {
1260                     break;
1261                 }
1262                 if ( bktr->clip_list[i+1].y_min != 0 &&
1263                      bktr->clip_list[i+1].y_max != 0 &&
1264                      bktr->clip_list[i].x_min > bktr->clip_list[i+1].x_min ) {
1265
1266                     bktr->max_clip_node = 0;
1267                     return (EINVAL);
1268
1269                  }
1270
1271                 if (bktr->clip_list[i].x_min >= bktr->clip_list[i].x_max ||
1272                     bktr->clip_list[i].y_min >= bktr->clip_list[i].y_max ||
1273                     bktr->clip_list[i].x_min < 0 ||
1274                     bktr->clip_list[i].x_max < 0 ||
1275                     bktr->clip_list[i].y_min < 0 ||
1276                     bktr->clip_list[i].y_max < 0 ) {
1277                     bktr->max_clip_node = 0;
1278                     return (EINVAL);
1279                 }
1280             }
1281
1282             bktr->dma_prog_loaded = FALSE;
1283
1284             break;
1285
1286         case METEORSTATUS:      /* get Bt848 status */
1287                 c_temp = INB(bktr, BKTR_DSTATUS);
1288                 temp = 0;
1289                 if (!(c_temp & 0x40)) temp |= METEOR_STATUS_HCLK;
1290                 if (!(c_temp & 0x10)) temp |= METEOR_STATUS_FIDT;
1291                 *(u_short *)arg = temp;
1292                 break;
1293
1294         case BT848SFMT:         /* set input format */
1295                 temp = *(unsigned long*)arg & BT848_IFORM_FORMAT;
1296                 temp_iform = INB(bktr, BKTR_IFORM);
1297                 temp_iform &= ~BT848_IFORM_FORMAT;
1298                 temp_iform &= ~BT848_IFORM_XTSEL;
1299                 OUTB(bktr, BKTR_IFORM, (temp_iform | temp | format_params[temp].iform_xtsel));
1300                 switch( temp ) {
1301                 case BT848_IFORM_F_AUTO:
1302                         bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1303                         METEOR_AUTOMODE;
1304                         break;
1305
1306                 case BT848_IFORM_F_NTSCM:
1307                 case BT848_IFORM_F_NTSCJ:
1308                         bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1309                                 METEOR_NTSC;
1310                         OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
1311                         OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
1312                         bktr->format_params = temp;
1313                         break;
1314
1315                 case BT848_IFORM_F_PALBDGHI:
1316                 case BT848_IFORM_F_PALN:
1317                 case BT848_IFORM_F_SECAM:
1318                 case BT848_IFORM_F_RSVD:
1319                 case BT848_IFORM_F_PALM:
1320                         bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1321                                 METEOR_PAL;
1322                         OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
1323                         OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
1324                         bktr->format_params = temp;
1325                         break;
1326
1327                 }
1328                 bktr->dma_prog_loaded = FALSE;
1329                 break;
1330
1331         case METEORSFMT:        /* set input format */
1332                 temp_iform = INB(bktr, BKTR_IFORM);
1333                 temp_iform &= ~BT848_IFORM_FORMAT;
1334                 temp_iform &= ~BT848_IFORM_XTSEL;
1335                 switch(*(unsigned long *)arg & METEOR_FORM_MASK ) {
1336                 case 0:         /* default */
1337                 case METEOR_FMT_NTSC:
1338                         bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1339                                 METEOR_NTSC;
1340                         OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_NTSCM |
1341                                          format_params[BT848_IFORM_F_NTSCM].iform_xtsel);
1342                         OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_NTSCM].adelay);
1343                         OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_NTSCM].bdelay);
1344                         bktr->format_params = BT848_IFORM_F_NTSCM;
1345                         break;
1346
1347                 case METEOR_FMT_PAL:
1348                         bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1349                                 METEOR_PAL;
1350                         OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_PALBDGHI |
1351                                          format_params[BT848_IFORM_F_PALBDGHI].iform_xtsel);
1352                         OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_PALBDGHI].adelay);
1353                         OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_PALBDGHI].bdelay);
1354                         bktr->format_params = BT848_IFORM_F_PALBDGHI;
1355                         break;
1356
1357                 case METEOR_FMT_AUTOMODE:
1358                         bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
1359                                 METEOR_AUTOMODE;
1360                         OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_AUTO |
1361                                          format_params[BT848_IFORM_F_AUTO].iform_xtsel);
1362                         break;
1363
1364                 default:
1365                         return( EINVAL );
1366                 }
1367                 bktr->dma_prog_loaded = FALSE;
1368                 break;
1369
1370         case METEORGFMT:        /* get input format */
1371                 *(u_long *)arg = bktr->flags & METEOR_FORM_MASK;
1372                 break;
1373
1374
1375         case BT848GFMT:         /* get input format */
1376                 *(u_long *)arg = INB(bktr, BKTR_IFORM) & BT848_IFORM_FORMAT;
1377                 break;
1378
1379         case METEORSCOUNT:      /* (re)set error counts */
1380                 counts = (struct meteor_counts *) arg;
1381                 bktr->fifo_errors = counts->fifo_errors;
1382                 bktr->dma_errors = counts->dma_errors;
1383                 bktr->frames_captured = counts->frames_captured;
1384                 bktr->even_fields_captured = counts->even_fields_captured;
1385                 bktr->odd_fields_captured = counts->odd_fields_captured;
1386                 break;
1387
1388         case METEORGCOUNT:      /* get error counts */
1389                 counts = (struct meteor_counts *) arg;
1390                 counts->fifo_errors = bktr->fifo_errors;
1391                 counts->dma_errors = bktr->dma_errors;
1392                 counts->frames_captured = bktr->frames_captured;
1393                 counts->even_fields_captured = bktr->even_fields_captured;
1394                 counts->odd_fields_captured = bktr->odd_fields_captured;
1395                 break;
1396
1397         case METEORGVIDEO:
1398                 video = (struct meteor_video *)arg;
1399                 video->addr = bktr->video.addr;
1400                 video->width = bktr->video.width;
1401                 video->banksize = bktr->video.banksize;
1402                 video->ramsize = bktr->video.ramsize;
1403                 break;
1404
1405         case METEORSVIDEO:
1406                 video = (struct meteor_video *)arg;
1407                 bktr->video.addr = video->addr;
1408                 bktr->video.width = video->width;
1409                 bktr->video.banksize = video->banksize;
1410                 bktr->video.ramsize = video->ramsize;
1411                 break;
1412
1413         case METEORSFPS:
1414                 set_fps(bktr, *(u_short *)arg);
1415                 break;
1416
1417         case METEORGFPS:
1418                 *(u_short *)arg = bktr->fps;
1419                 break;
1420
1421         case METEORSHUE:        /* set hue */
1422                 OUTB(bktr, BKTR_HUE, (*(u_char *) arg) & 0xff);
1423                 break;
1424
1425         case METEORGHUE:        /* get hue */
1426                 *(u_char *)arg = INB(bktr, BKTR_HUE);
1427                 break;
1428
1429         case METEORSBRIG:       /* set brightness */
1430                 char_temp =    ( *(u_char *)arg & 0xff) - 128;
1431                 OUTB(bktr, BKTR_BRIGHT, char_temp);
1432
1433                 break;
1434
1435         case METEORGBRIG:       /* get brightness */
1436                 *(u_char *)arg = INB(bktr, BKTR_BRIGHT);
1437                 break;
1438
1439         case METEORSCSAT:       /* set chroma saturation */
1440                 temp = (int)*(u_char *)arg;
1441
1442                 OUTB(bktr, BKTR_SAT_U_LO, (temp << 1) & 0xff);
1443                 OUTB(bktr, BKTR_SAT_V_LO, (temp << 1) & 0xff);
1444                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
1445                                      & ~(BT848_E_CONTROL_SAT_U_MSB
1446                                          | BT848_E_CONTROL_SAT_V_MSB));
1447                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
1448                                      & ~(BT848_O_CONTROL_SAT_U_MSB |
1449                                          BT848_O_CONTROL_SAT_V_MSB));
1450
1451                 if ( temp & BIT_SEVEN_HIGH ) {
1452                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
1453                                              | (BT848_E_CONTROL_SAT_U_MSB
1454                                                 | BT848_E_CONTROL_SAT_V_MSB));
1455                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
1456                                              | (BT848_O_CONTROL_SAT_U_MSB
1457                                                 | BT848_O_CONTROL_SAT_V_MSB));
1458                 }
1459                 break;
1460
1461         case METEORGCSAT:       /* get chroma saturation */
1462                 temp = (INB(bktr, BKTR_SAT_V_LO) >> 1) & 0xff;
1463                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
1464                         temp |= BIT_SEVEN_HIGH;
1465                 *(u_char *)arg = (u_char)temp;
1466                 break;
1467
1468         case METEORSCONT:       /* set contrast */
1469                 temp = (int)*(u_char *)arg & 0xff;
1470                 temp <<= 1;
1471                 OUTB(bktr, BKTR_CONTRAST_LO, temp & 0xff);
1472                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_CON_MSB);
1473                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_CON_MSB);
1474                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) |
1475                         (((temp & 0x100) >> 6 ) & BT848_E_CONTROL_CON_MSB));
1476                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) |
1477                         (((temp & 0x100) >> 6 ) & BT848_O_CONTROL_CON_MSB));
1478                 break;
1479
1480         case METEORGCONT:       /* get contrast */
1481                 temp = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
1482                 temp |= ((int)INB(bktr, BKTR_O_CONTROL) & 0x04) << 6;
1483                 *(u_char *)arg = (u_char)((temp >> 1) & 0xff);
1484                 break;
1485
1486         case BT848SCBUF:        /* set Clear-Buffer-on-start flag */
1487                 bktr->clr_on_start = (*(int *)arg != 0);
1488                 break;
1489
1490         case BT848GCBUF:        /* get Clear-Buffer-on-start flag */
1491                 *(int *)arg = (int) bktr->clr_on_start;
1492                 break;
1493
1494         case METEORSSIGNAL:
1495                 sig = *(int *)arg;
1496                 /* Historically, applications used METEOR_SIG_MODE_MASK
1497                  * to reset signal delivery.
1498                  */
1499                 if (sig == METEOR_SIG_MODE_MASK)
1500                         sig = 0;
1501                 if (sig < 0 || sig > _SIG_MAXSIG)
1502                         return (EINVAL);
1503                 bktr->signal = sig;
1504                 bktr->proc = sig ? td->td_proc : NULL;
1505                 break;
1506
1507         case METEORGSIGNAL:
1508                 *(int *)arg = bktr->signal;
1509                 break;
1510
1511         case METEORCAPTUR:
1512                 temp = bktr->flags;
1513                 switch (*(int *) arg) {
1514                 case METEOR_CAP_SINGLE:
1515
1516                         if (bktr->bigbuf==0)    /* no frame buffer allocated */
1517                                 return( ENOMEM );
1518                         /* already capturing */
1519                         if (temp & METEOR_CAP_MASK)
1520                                 return( EIO );
1521
1522
1523
1524                         start_capture(bktr, METEOR_SINGLE);
1525
1526                         /* wait for capture to complete */
1527                         OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
1528                         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1529                         OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1530
1531                         OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1532                                             BT848_INT_RISCI      |
1533                                             BT848_INT_VSYNC      |
1534                                             BT848_INT_FMTCHG);
1535
1536                         OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1537                         error = tsleep(BKTR_SLEEP, BKTRPRI, "captur", hz);
1538                         if (error && (error != ERESTART)) {
1539                                 /*  Here if we didn't get complete frame  */
1540 #ifdef DIAGNOSTIC
1541                                 kprintf( "%s: ioctl: tsleep error %d %x\n",
1542                                         bktr_name(bktr), error,
1543                                         INL(bktr, BKTR_RISC_COUNT));
1544 #endif
1545
1546                                 /* stop dma */
1547                                 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1548
1549                                 /* disable risc, leave fifo running */
1550                                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1551                         }
1552
1553                         bktr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK);
1554                         /* FIXME: should we set bt848->int_stat ??? */
1555                         break;
1556
1557                 case METEOR_CAP_CONTINOUS:
1558                         if (bktr->bigbuf==0)    /* no frame buffer allocated */
1559                                 return( ENOMEM );
1560                         /* already capturing */
1561                         if (temp & METEOR_CAP_MASK)
1562                             return( EIO );
1563
1564
1565                         start_capture(bktr, METEOR_CONTIN);
1566
1567                         /* Clear the interrypt status register */
1568                         OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1569
1570                         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1571                         OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1572                         OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
1573
1574                         OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1575                                             BT848_INT_RISCI      |
1576                                             BT848_INT_VSYNC      |
1577                                             BT848_INT_FMTCHG);
1578 #ifdef BT848_DUMP
1579                         dump_bt848(bktr);
1580 #endif
1581                         break;
1582
1583                 case METEOR_CAP_STOP_CONT:
1584                         if (bktr->flags & METEOR_CONTIN) {
1585                                 /* turn off capture */
1586                                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1587                                 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
1588                                 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1589                                 bktr->flags &=
1590                                         ~(METEOR_CONTIN | METEOR_WANT_MASK);
1591
1592                         }
1593                 }
1594                 break;
1595
1596         case METEORSETGEO:
1597                 /* can't change parameters while capturing */
1598                 if (bktr->flags & METEOR_CAP_MASK)
1599                         return( EBUSY );
1600
1601
1602                 geo = (struct meteor_geomet *) arg;
1603
1604                 error = 0;
1605                 /* Either even or odd, if even & odd, then these a zero */
1606                 if ((geo->oformat & METEOR_GEO_ODD_ONLY) &&
1607                         (geo->oformat & METEOR_GEO_EVEN_ONLY)) {
1608                         kprintf( "%s: ioctl: Geometry odd or even only.\n",
1609                                 bktr_name(bktr));
1610                         return( EINVAL );
1611                 }
1612
1613                 /* set/clear even/odd flags */
1614                 if (geo->oformat & METEOR_GEO_ODD_ONLY)
1615                         bktr->flags |= METEOR_ONLY_ODD_FIELDS;
1616                 else
1617                         bktr->flags &= ~METEOR_ONLY_ODD_FIELDS;
1618                 if (geo->oformat & METEOR_GEO_EVEN_ONLY)
1619                         bktr->flags |= METEOR_ONLY_EVEN_FIELDS;
1620                 else
1621                         bktr->flags &= ~METEOR_ONLY_EVEN_FIELDS;
1622
1623                 if (geo->columns <= 0) {
1624                         kprintf(
1625                         "%s: ioctl: %d: columns must be greater than zero.\n",
1626                                 bktr_name(bktr), geo->columns);
1627                         error = EINVAL;
1628                 }
1629                 else if ((geo->columns & 0x3fe) != geo->columns) {
1630                         kprintf(
1631                         "%s: ioctl: %d: columns too large or not even.\n",
1632                                 bktr_name(bktr), geo->columns);
1633                         error = EINVAL;
1634                 }
1635
1636                 if (geo->rows <= 0) {
1637                         kprintf(
1638                         "%s: ioctl: %d: rows must be greater than zero.\n",
1639                                 bktr_name(bktr), geo->rows);
1640                         error = EINVAL;
1641                 }
1642                 else if (((geo->rows & 0x7fe) != geo->rows) ||
1643                         ((geo->oformat & METEOR_GEO_FIELD_MASK) &&
1644                                 ((geo->rows & 0x3fe) != geo->rows)) ) {
1645                         kprintf(
1646                         "%s: ioctl: %d: rows too large or not even.\n",
1647                                 bktr_name(bktr), geo->rows);
1648                         error = EINVAL;
1649                 }
1650
1651                 if (geo->frames > 32) {
1652                         kprintf("%s: ioctl: too many frames.\n",
1653                                bktr_name(bktr));
1654
1655                         error = EINVAL;
1656                 }
1657
1658                 if (error)
1659                         return( error );
1660
1661                 bktr->dma_prog_loaded = FALSE;
1662                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1663
1664                 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1665
1666                 if ((temp=(geo->rows * geo->columns * geo->frames * 2))) {
1667                         if (geo->oformat & METEOR_GEO_RGB24) temp = temp * 2;
1668
1669                         /* meteor_mem structure for SYNC Capture */
1670                         if (geo->frames > 1) temp += PAGE_SIZE;
1671
1672                         temp = btoc(temp);
1673                         if ((int) temp > bktr->alloc_pages
1674                             && bktr->video.addr == 0) {
1675
1676                                 buf = get_bktr_mem(unit, temp*PAGE_SIZE);
1677                                 if (buf != 0) {
1678                                         kmem_free(&kernel_map, bktr->bigbuf,
1679                                           (bktr->alloc_pages * PAGE_SIZE));
1680
1681                                         bktr->bigbuf = buf;
1682                                         bktr->alloc_pages = temp;
1683                                         if (bootverbose)
1684                                                 kprintf(
1685                                 "%s: ioctl: Allocating %d bytes\n",
1686                                                         bktr_name(bktr), temp*PAGE_SIZE);
1687                                 }
1688                                 else
1689                                         error = ENOMEM;
1690                         }
1691                 }
1692
1693                 if (error)
1694                         return error;
1695
1696                 bktr->rows = geo->rows;
1697                 bktr->cols = geo->columns;
1698                 bktr->frames = geo->frames;
1699
1700                 /*  Pixel format (if in meteor pixfmt compatibility mode)  */
1701                 if ( bktr->pixfmt_compat ) {
1702                         bktr->format = METEOR_GEO_YUV_422;
1703                         switch (geo->oformat & METEOR_GEO_OUTPUT_MASK) {
1704                         case 0:                 /* default */
1705                         case METEOR_GEO_RGB16:
1706                                     bktr->format = METEOR_GEO_RGB16;
1707                                     break;
1708                         case METEOR_GEO_RGB24:
1709                                     bktr->format = METEOR_GEO_RGB24;
1710                                     break;
1711                         case METEOR_GEO_YUV_422:
1712                                     bktr->format = METEOR_GEO_YUV_422;
1713                                     if (geo->oformat & METEOR_GEO_YUV_12)
1714                                         bktr->format = METEOR_GEO_YUV_12;
1715                                     break;
1716                         case METEOR_GEO_YUV_PACKED:
1717                                     bktr->format = METEOR_GEO_YUV_PACKED;
1718                                     break;
1719                         }
1720                         bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
1721                 }
1722
1723                 if (bktr->flags & METEOR_CAP_MASK) {
1724
1725                         if (bktr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
1726                                 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
1727                                 case METEOR_ONLY_ODD_FIELDS:
1728                                         bktr->flags |= METEOR_WANT_ODD;
1729                                         break;
1730                                 case METEOR_ONLY_EVEN_FIELDS:
1731                                         bktr->flags |= METEOR_WANT_EVEN;
1732                                         break;
1733                                 default:
1734                                         bktr->flags |= METEOR_WANT_MASK;
1735                                         break;
1736                                 }
1737
1738                                 start_capture(bktr, METEOR_CONTIN);
1739                                 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1740                                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1741                                 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1742                                 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1743                                                     BT848_INT_VSYNC      |
1744                                                     BT848_INT_FMTCHG);
1745                         }
1746                 }
1747                 break;
1748         /* end of METEORSETGEO */
1749
1750         /* FIXME. The Capture Area currently has the following restrictions:
1751         GENERAL
1752          y_offset may need to be even in interlaced modes
1753         RGB24 - Interlaced mode
1754          x_size must be greater than or equal to 1.666*METEORSETGEO width (cols)
1755          y_size must be greater than or equal to METEORSETGEO height (rows)
1756         RGB24 - Even Only (or Odd Only) mode
1757          x_size must be greater than or equal to 1.666*METEORSETGEO width (cols)
1758          y_size must be greater than or equal to 2*METEORSETGEO height (rows)
1759         YUV12 - Interlaced mode
1760          x_size must be greater than or equal to METEORSETGEO width (cols)
1761          y_size must be greater than or equal to METEORSETGEO height (rows)
1762         YUV12 - Even Only (or Odd Only) mode
1763          x_size must be greater than or equal to METEORSETGEO width (cols)
1764          y_size must be greater than or equal to 2*METEORSETGEO height (rows)
1765         */
1766
1767         case BT848_SCAPAREA: /* set capture area of each video frame */
1768                 /* can't change parameters while capturing */
1769                 if (bktr->flags & METEOR_CAP_MASK)
1770                         return( EBUSY );
1771
1772                 cap_area = (struct bktr_capture_area *) arg;
1773                 bktr->capture_area_x_offset = cap_area->x_offset;
1774                 bktr->capture_area_y_offset = cap_area->y_offset;
1775                 bktr->capture_area_x_size   = cap_area->x_size;
1776                 bktr->capture_area_y_size   = cap_area->y_size;
1777                 bktr->capture_area_enabled  = TRUE;
1778
1779                 bktr->dma_prog_loaded = FALSE;
1780                 break;
1781
1782         case BT848_GCAPAREA: /* get capture area of each video frame */
1783                 cap_area = (struct bktr_capture_area *) arg;
1784                 if (bktr->capture_area_enabled == FALSE) {
1785                         cap_area->x_offset = 0;
1786                         cap_area->y_offset = 0;
1787                         cap_area->x_size   = format_params[
1788                                 bktr->format_params].scaled_hactive;
1789                         cap_area->y_size   = format_params[
1790                                 bktr->format_params].vactive;
1791                 } else {
1792                         cap_area->x_offset = bktr->capture_area_x_offset;
1793                         cap_area->y_offset = bktr->capture_area_y_offset;
1794                         cap_area->x_size   = bktr->capture_area_x_size;
1795                         cap_area->y_size   = bktr->capture_area_y_size;
1796                 }
1797                 break;
1798
1799         default:
1800                 return common_ioctl( bktr, cmd, arg );
1801         }
1802
1803         return( 0 );
1804 }
1805
1806 /*
1807  * tuner ioctls
1808  */
1809 int
1810 tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td )
1811 {
1812         int             tmp_int;
1813         int             temp, temp1;
1814         int             offset;
1815         int             count;
1816         u_char          *buf;
1817         u_long          par;
1818         u_char          write;
1819         int             i2c_addr;
1820         int             i2c_port;
1821         u_long          data;
1822
1823         switch ( cmd ) {
1824
1825         case REMOTE_GETKEY:
1826                 /* Read the last key pressed by the Remote Control */
1827                 if (bktr->remote_control == 0) return (EINVAL);
1828                 remote_read(bktr, (struct bktr_remote *)arg);
1829                 break;
1830
1831 #if defined( TUNER_AFC )
1832         case TVTUNER_SETAFC:
1833                 bktr->tuner.afc = (*(int *)arg != 0);
1834                 break;
1835
1836         case TVTUNER_GETAFC:
1837                 *(int *)arg = bktr->tuner.afc;
1838                 /* XXX Perhaps use another bit to indicate AFC success? */
1839                 break;
1840 #endif /* TUNER_AFC */
1841
1842         case TVTUNER_SETCHNL:
1843                 temp_mute( bktr, TRUE );
1844                 temp = tv_channel( bktr, (int)*(unsigned long *)arg );
1845                 if ( temp < 0 ) {
1846                         temp_mute( bktr, FALSE );
1847                         return( EINVAL );
1848                 }
1849                 *(unsigned long *)arg = temp;
1850
1851                 /* after every channel change, we must restart the MSP34xx */
1852                 /* audio chip to reselect NICAM STEREO or MONO audio */
1853                 if ( bktr->card.msp3400c )
1854                   msp_autodetect( bktr );
1855
1856                 /* after every channel change, we must restart the DPL35xx */
1857                 if ( bktr->card.dpl3518a )
1858                   dpl_autodetect( bktr );
1859
1860                 temp_mute( bktr, FALSE );
1861                 break;
1862
1863         case TVTUNER_GETCHNL:
1864                 *(unsigned long *)arg = bktr->tuner.channel;
1865                 break;
1866
1867         case TVTUNER_SETTYPE:
1868                 temp = *(unsigned long *)arg;
1869                 if ( (temp < CHNLSET_MIN) || (temp > CHNLSET_MAX) )
1870                         return( EINVAL );
1871                 bktr->tuner.chnlset = temp;
1872                 break;
1873
1874         case TVTUNER_GETTYPE:
1875                 *(unsigned long *)arg = bktr->tuner.chnlset;
1876                 break;
1877
1878         case TVTUNER_GETSTATUS:
1879                 temp = get_tuner_status( bktr );
1880                 *(unsigned long *)arg = temp & 0xff;
1881                 break;
1882
1883         case TVTUNER_SETFREQ:
1884                 temp_mute( bktr, TRUE );
1885                 temp = tv_freq( bktr, (int)*(unsigned long *)arg, TV_FREQUENCY);
1886                 temp_mute( bktr, FALSE );
1887                 if ( temp < 0 ) {
1888                         temp_mute( bktr, FALSE );
1889                         return( EINVAL );
1890                 }
1891                 *(unsigned long *)arg = temp;
1892
1893                 /* after every channel change, we must restart the MSP34xx */
1894                 /* audio chip to reselect NICAM STEREO or MONO audio */
1895                 if ( bktr->card.msp3400c )
1896                   msp_autodetect( bktr );
1897
1898                 /* after every channel change, we must restart the DPL35xx */
1899                 if ( bktr->card.dpl3518a )
1900                   dpl_autodetect( bktr );
1901
1902                 temp_mute( bktr, FALSE );
1903                 break;
1904
1905         case TVTUNER_GETFREQ:
1906                 *(unsigned long *)arg = bktr->tuner.frequency;
1907                 break;
1908
1909         case TVTUNER_GETCHNLSET:
1910                 return tuner_getchnlset((struct bktr_chnlset *)arg);
1911
1912         case BT848_SAUDIO:      /* set audio channel */
1913                 if ( set_audio( bktr, *(int*)arg ) < 0 )
1914                         return( EIO );
1915                 break;
1916
1917         /* hue is a 2's compliment number, -90' to +89.3' in 0.7' steps */
1918         case BT848_SHUE:        /* set hue */
1919                 OUTB(bktr, BKTR_HUE, (u_char)(*(int*)arg & 0xff));
1920                 break;
1921
1922         case BT848_GHUE:        /* get hue */
1923                 *(int*)arg = (signed char)(INB(bktr, BKTR_HUE) & 0xff);
1924                 break;
1925
1926         /* brightness is a 2's compliment #, -50 to +%49.6% in 0.39% steps */
1927         case BT848_SBRIG:       /* set brightness */
1928                 OUTB(bktr, BKTR_BRIGHT, (u_char)(*(int *)arg & 0xff));
1929                 break;
1930
1931         case BT848_GBRIG:       /* get brightness */
1932                 *(int *)arg = (signed char)(INB(bktr, BKTR_BRIGHT) & 0xff);
1933                 break;
1934
1935         /*  */
1936         case BT848_SCSAT:       /* set chroma saturation */
1937                 tmp_int = *(int*)arg;
1938
1939                 temp = INB(bktr, BKTR_E_CONTROL);
1940                 temp1 = INB(bktr, BKTR_O_CONTROL);
1941                 if ( tmp_int & BIT_EIGHT_HIGH ) {
1942                         temp |= (BT848_E_CONTROL_SAT_U_MSB |
1943                                  BT848_E_CONTROL_SAT_V_MSB);
1944                         temp1 |= (BT848_O_CONTROL_SAT_U_MSB |
1945                                   BT848_O_CONTROL_SAT_V_MSB);
1946                 }
1947                 else {
1948                         temp &= ~(BT848_E_CONTROL_SAT_U_MSB |
1949                                   BT848_E_CONTROL_SAT_V_MSB);
1950                         temp1 &= ~(BT848_O_CONTROL_SAT_U_MSB |
1951                                    BT848_O_CONTROL_SAT_V_MSB);
1952                 }
1953
1954                 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
1955                 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
1956                 OUTB(bktr, BKTR_E_CONTROL, temp);
1957                 OUTB(bktr, BKTR_O_CONTROL, temp1);
1958                 break;
1959
1960         case BT848_GCSAT:       /* get chroma saturation */
1961                 tmp_int = (int)(INB(bktr, BKTR_SAT_V_LO) & 0xff);
1962                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
1963                         tmp_int |= BIT_EIGHT_HIGH;
1964                 *(int*)arg = tmp_int;
1965                 break;
1966
1967         /*  */
1968         case BT848_SVSAT:       /* set chroma V saturation */
1969                 tmp_int = *(int*)arg;
1970
1971                 temp = INB(bktr, BKTR_E_CONTROL);
1972                 temp1 = INB(bktr, BKTR_O_CONTROL);
1973                 if ( tmp_int & BIT_EIGHT_HIGH) {
1974                         temp |= BT848_E_CONTROL_SAT_V_MSB;
1975                         temp1 |= BT848_O_CONTROL_SAT_V_MSB;
1976                 }
1977                 else {
1978                         temp &= ~BT848_E_CONTROL_SAT_V_MSB;
1979                         temp1 &= ~BT848_O_CONTROL_SAT_V_MSB;
1980                 }
1981
1982                 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
1983                 OUTB(bktr, BKTR_E_CONTROL, temp);
1984                 OUTB(bktr, BKTR_O_CONTROL, temp1);
1985                 break;
1986
1987         case BT848_GVSAT:       /* get chroma V saturation */
1988                 tmp_int = (int)INB(bktr, BKTR_SAT_V_LO) & 0xff;
1989                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
1990                         tmp_int |= BIT_EIGHT_HIGH;
1991                 *(int*)arg = tmp_int;
1992                 break;
1993
1994         /*  */
1995         case BT848_SUSAT:       /* set chroma U saturation */
1996                 tmp_int = *(int*)arg;
1997
1998                 temp = INB(bktr, BKTR_E_CONTROL);
1999                 temp1 = INB(bktr, BKTR_O_CONTROL);
2000                 if ( tmp_int & BIT_EIGHT_HIGH ) {
2001                         temp |= BT848_E_CONTROL_SAT_U_MSB;
2002                         temp1 |= BT848_O_CONTROL_SAT_U_MSB;
2003                 }
2004                 else {
2005                         temp &= ~BT848_E_CONTROL_SAT_U_MSB;
2006                         temp1 &= ~BT848_O_CONTROL_SAT_U_MSB;
2007                 }
2008
2009                 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2010                 OUTB(bktr, BKTR_E_CONTROL, temp);
2011                 OUTB(bktr, BKTR_O_CONTROL, temp1);
2012                 break;
2013
2014         case BT848_GUSAT:       /* get chroma U saturation */
2015                 tmp_int = (int)INB(bktr, BKTR_SAT_U_LO) & 0xff;
2016                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_U_MSB )
2017                         tmp_int |= BIT_EIGHT_HIGH;
2018                 *(int*)arg = tmp_int;
2019                 break;
2020
2021 /* lr 970528 luma notch etc - 3 high bits of e_control/o_control */
2022
2023         case BT848_SLNOTCH:     /* set luma notch */
2024                 tmp_int = (*(int *)arg & 0x7) << 5 ;
2025                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~0xe0);
2026                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~0xe0);
2027                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | tmp_int);
2028                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | tmp_int);
2029                 break;
2030
2031         case BT848_GLNOTCH:     /* get luma notch */
2032                 *(int *)arg = (int) ( (INB(bktr, BKTR_E_CONTROL) & 0xe0) >> 5) ;
2033                 break;
2034
2035
2036         /*  */
2037         case BT848_SCONT:       /* set contrast */
2038                 tmp_int = *(int*)arg;
2039
2040                 temp = INB(bktr, BKTR_E_CONTROL);
2041                 temp1 = INB(bktr, BKTR_O_CONTROL);
2042                 if ( tmp_int & BIT_EIGHT_HIGH ) {
2043                         temp |= BT848_E_CONTROL_CON_MSB;
2044                         temp1 |= BT848_O_CONTROL_CON_MSB;
2045                 }
2046                 else {
2047                         temp &= ~BT848_E_CONTROL_CON_MSB;
2048                         temp1 &= ~BT848_O_CONTROL_CON_MSB;
2049                 }
2050
2051                 OUTB(bktr, BKTR_CONTRAST_LO, (u_char)(tmp_int & 0xff));
2052                 OUTB(bktr, BKTR_E_CONTROL, temp);
2053                 OUTB(bktr, BKTR_O_CONTROL, temp1);
2054                 break;
2055
2056         case BT848_GCONT:       /* get contrast */
2057                 tmp_int = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
2058                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_CON_MSB )
2059                         tmp_int |= BIT_EIGHT_HIGH;
2060                 *(int*)arg = tmp_int;
2061                 break;
2062
2063                 /*  FIXME:  SCBARS and CCBARS require a valid int *        */
2064                 /*    argument to succeed, but its not used; consider      */
2065                 /*    using the arg to store the on/off state so           */
2066                 /*    there's only one ioctl() needed to turn cbars on/off */
2067         case BT848_SCBARS:      /* set colorbar output */
2068                 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_COLOR_BARS);
2069                 break;
2070
2071         case BT848_CCBARS:      /* clear colorbar output */
2072                 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) & ~(BT848_COLOR_CTL_COLOR_BARS));
2073                 break;
2074
2075         case BT848_GAUDIO:      /* get audio channel */
2076                 temp = bktr->audio_mux_select;
2077                 if ( bktr->audio_mute_state == TRUE )
2078                         temp |= AUDIO_MUTE;
2079                 *(int*)arg = temp;
2080                 break;
2081
2082         case BT848_SBTSC:       /* set audio channel */
2083                 if ( set_BTSC( bktr, *(int*)arg ) < 0 )
2084                         return( EIO );
2085                 break;
2086
2087         case BT848_WEEPROM:     /* write eeprom */
2088                 offset = (((struct eeProm *)arg)->offset);
2089                 count = (((struct eeProm *)arg)->count);
2090                 buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
2091                 if ( writeEEProm( bktr, offset, count, buf ) < 0 )
2092                         return( EIO );
2093                 break;
2094
2095         case BT848_REEPROM:     /* read eeprom */
2096                 offset = (((struct eeProm *)arg)->offset);
2097                 count = (((struct eeProm *)arg)->count);
2098                 buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
2099                 if ( readEEProm( bktr, offset, count, buf ) < 0 )
2100                         return( EIO );
2101                 break;
2102
2103         case BT848_SIGNATURE:
2104                 offset = (((struct eeProm *)arg)->offset);
2105                 count = (((struct eeProm *)arg)->count);
2106                 buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
2107                 if ( signCard( bktr, offset, count, buf ) < 0 )
2108                         return( EIO );
2109                 break;
2110
2111         /* Ioctl's for direct gpio access */
2112 #ifdef BKTR_GPIO_ACCESS
2113         case BT848_GPIO_GET_EN:
2114                 *(int*)arg = INL(bktr, BKTR_GPIO_OUT_EN);
2115                 break;
2116
2117         case BT848_GPIO_SET_EN:
2118                 OUTL(bktr, BKTR_GPIO_OUT_EN, *(int*)arg);
2119                 break;
2120
2121         case BT848_GPIO_GET_DATA:
2122                 *(int*)arg = INL(bktr, BKTR_GPIO_DATA);
2123                 break;
2124
2125         case BT848_GPIO_SET_DATA:
2126                 OUTL(bktr, BKTR_GPIO_DATA, *(int*)arg);
2127                 break;
2128 #endif /* BKTR_GPIO_ACCESS */
2129
2130         /* Ioctl's for running the tuner device in radio mode           */
2131
2132         case RADIO_GETMODE:
2133             *(unsigned char *)arg = bktr->tuner.radio_mode;
2134             break;
2135
2136         case RADIO_SETMODE:
2137             bktr->tuner.radio_mode = *(unsigned char *)arg;
2138             break;
2139
2140         case RADIO_GETFREQ:
2141             *(unsigned long *)arg = bktr->tuner.frequency;
2142             break;
2143
2144         case RADIO_SETFREQ:
2145             /* The argument to this ioctl is NOT freq*16. It is
2146             ** freq*100.
2147             */
2148
2149             temp=(int)*(unsigned long *)arg;
2150
2151 #ifdef BKTR_RADIO_DEBUG
2152             kprintf("%s: arg=%d temp=%d\n", bktr_name(bktr),
2153                    (int)*(unsigned long *)arg, temp);
2154 #endif
2155
2156 #ifndef BKTR_RADIO_NOFREQCHECK
2157             /* According to the spec. sheet the band: 87.5MHz-108MHz    */
2158             /* is supported.                                            */
2159             if(temp<8750 || temp>10800) {
2160               kprintf("%s: Radio frequency out of range\n", bktr_name(bktr));
2161               return(EINVAL);
2162               }
2163 #endif
2164             temp_mute( bktr, TRUE );
2165             temp = tv_freq( bktr, temp, FM_RADIO_FREQUENCY );
2166             temp_mute( bktr, FALSE );
2167 #ifdef BKTR_RADIO_DEBUG
2168   if(temp)
2169     kprintf("%s: tv_freq returned: %d\n", bktr_name(bktr), temp);
2170 #endif
2171             if ( temp < 0 )
2172                     return( EINVAL );
2173             *(unsigned long *)arg = temp;
2174             break;
2175
2176         /* Luigi's I2CWR ioctl */
2177         case BT848_I2CWR:
2178                 par = *(u_long *)arg;
2179                 write = (par >> 24) & 0xff ;
2180                 i2c_addr = (par >> 16) & 0xff ;
2181                 i2c_port = (par >> 8) & 0xff ;
2182                 data = (par) & 0xff ;
2183
2184                 if (write) {
2185                         i2cWrite( bktr, i2c_addr, i2c_port, data);
2186                 } else {
2187                         data = i2cRead( bktr, i2c_addr);
2188                 }
2189                 *(u_long *)arg = (par & 0xffffff00) | ( data & 0xff );
2190                 break;
2191
2192
2193 #ifdef BT848_MSP_READ
2194         /* I2C ioctls to allow userland access to the MSP chip */
2195         case BT848_MSP_READ:
2196                 {
2197                 struct bktr_msp_control *msp;
2198                 msp = (struct bktr_msp_control *) arg;
2199                 msp->data = msp_dpl_read(bktr, bktr->msp_addr,
2200                                          msp->function, msp->address);
2201                 break;
2202                 }
2203
2204         case BT848_MSP_WRITE:
2205                 {
2206                 struct bktr_msp_control *msp;
2207                 msp = (struct bktr_msp_control *) arg;
2208                 msp_dpl_write(bktr, bktr->msp_addr, msp->function,
2209                              msp->address, msp->data );
2210                 break;
2211                 }
2212
2213         case BT848_MSP_RESET:
2214                 msp_dpl_reset(bktr, bktr->msp_addr);
2215                 break;
2216 #endif
2217
2218         default:
2219                 return common_ioctl( bktr, cmd, arg );
2220         }
2221
2222         return( 0 );
2223 }
2224
2225
2226 /*
2227  * common ioctls
2228  */
2229 static int
2230 common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg )
2231 {
2232         int                           pixfmt;
2233         unsigned int                  temp;
2234         struct meteor_pixfmt          *pf_pub;
2235
2236         switch (cmd) {
2237
2238         case METEORSINPUT:      /* set input device */
2239                 /*Bt848 has 3 MUX Inputs. Bt848A/849A/878/879 has 4 MUX Inputs*/
2240                 /* On the original bt848 boards, */
2241                 /*   Tuner is MUX0, RCA is MUX1, S-Video is MUX2 */
2242                 /* On the Hauppauge bt878 boards, */
2243                 /*   Tuner is MUX0, RCA is MUX3 */
2244                 /* Unfortunatly Meteor driver codes DEV_RCA as DEV_0, so we */
2245                 /* stick with this system in our Meteor Emulation */
2246
2247                 switch(*(unsigned long *)arg & METEOR_DEV_MASK) {
2248
2249                 /* this is the RCA video input */
2250                 case 0:         /* default */
2251                 case METEOR_INPUT_DEV0:
2252                   /* METEOR_INPUT_DEV_RCA: */
2253                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2254                           | METEOR_DEV0;
2255                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM)
2256                                          & ~BT848_IFORM_MUXSEL);
2257
2258                         /* work around for new Hauppauge 878 cards */
2259                         if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2260                                 (bktr->id==BROOKTREE_878 ||
2261                                  bktr->id==BROOKTREE_879) )
2262                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2263                         else
2264                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2265
2266                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2267                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2268                         set_audio( bktr, AUDIO_EXTERN );
2269                         break;
2270
2271                 /* this is the tuner input */
2272                 case METEOR_INPUT_DEV1:
2273                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2274                                 | METEOR_DEV1;
2275                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2276                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX0);
2277                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2278                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2279                         set_audio( bktr, AUDIO_TUNER );
2280                         break;
2281
2282                 /* this is the S-VHS input, but with a composite camera */
2283                 case METEOR_INPUT_DEV2:
2284                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2285                                 | METEOR_DEV2;
2286                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2287                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2288                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2289                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_O_CONTROL_COMP);
2290                         set_audio( bktr, AUDIO_EXTERN );
2291                         break;
2292
2293                 /* this is the S-VHS input */
2294                 case METEOR_INPUT_DEV_SVIDEO:
2295                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2296                                 | METEOR_DEV_SVIDEO;
2297                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2298                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2299                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_COMP);
2300                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_COMP);
2301                         set_audio( bktr, AUDIO_EXTERN );
2302                         break;
2303
2304                 case METEOR_INPUT_DEV3:
2305                   if ((bktr->id == BROOKTREE_848A) ||
2306                       (bktr->id == BROOKTREE_849A) ||
2307                       (bktr->id == BROOKTREE_878) ||
2308                       (bktr->id == BROOKTREE_879) ) {
2309                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2310                                 | METEOR_DEV3;
2311                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2312
2313                         /* work around for new Hauppauge 878 cards */
2314                         if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2315                                 (bktr->id==BROOKTREE_878 ||
2316                                  bktr->id==BROOKTREE_879) )
2317                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2318                         else
2319                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2320
2321                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2322                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2323                         set_audio( bktr, AUDIO_EXTERN );
2324
2325                         break;
2326                   }
2327
2328                 default:
2329                         return( EINVAL );
2330                 }
2331                 break;
2332
2333         case METEORGINPUT:      /* get input device */
2334                 *(u_long *)arg = bktr->flags & METEOR_DEV_MASK;
2335                 break;
2336
2337         case METEORSACTPIXFMT:
2338                 if (( *(int *)arg < 0 ) ||
2339                     ( *(int *)arg >= PIXFMT_TABLE_SIZE ))
2340                         return( EINVAL );
2341
2342                 bktr->pixfmt          = *(int *)arg;
2343                 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
2344                      | pixfmt_swap_flags( bktr->pixfmt ));
2345                 bktr->pixfmt_compat   = FALSE;
2346                 break;
2347
2348         case METEORGACTPIXFMT:
2349                 *(int *)arg = bktr->pixfmt;
2350                 break;
2351
2352         case METEORGSUPPIXFMT :
2353                 pf_pub = (struct meteor_pixfmt *)arg;
2354                 pixfmt = pf_pub->index;
2355
2356                 if (( pixfmt < 0 ) || ( pixfmt >= PIXFMT_TABLE_SIZE ))
2357                         return( EINVAL );
2358
2359                 memcpy( pf_pub, &pixfmt_table[ pixfmt ].public,
2360                         sizeof( *pf_pub ) );
2361
2362                 /*  Patch in our format index  */
2363                 pf_pub->index       = pixfmt;
2364                 break;
2365
2366 #if defined( STATUS_SUM )
2367         case BT848_GSTATUS:     /* reap status */
2368                 {
2369                 crit_enter();
2370                 temp = status_sum;
2371                 status_sum = 0;
2372                 crit_exit();
2373                 *(u_int*)arg = temp;
2374                 break;
2375                 }
2376 #endif /* STATUS_SUM */
2377
2378         default:
2379                 return( ENOTTY );
2380         }
2381
2382         return( 0 );
2383 }
2384
2385
2386
2387
2388 /******************************************************************************
2389  * bt848 RISC programming routines:
2390  */
2391
2392
2393 /*
2394  *
2395  */
2396 #ifdef BT848_DEBUG
2397 static int
2398 dump_bt848( bktr_ptr_t bktr )
2399 {
2400         int     r[60]={
2401                            4,    8, 0xc, 0x8c, 0x10, 0x90, 0x14, 0x94,
2402                         0x18, 0x98, 0x1c, 0x9c, 0x20, 0xa0, 0x24, 0xa4,
2403                         0x28, 0x2c, 0xac, 0x30, 0x34, 0x38, 0x3c, 0x40,
2404                         0xc0, 0x48, 0x4c, 0xcc, 0x50, 0xd0, 0xd4, 0x60,
2405                         0x64, 0x68, 0x6c, 0xec, 0xd8, 0xdc, 0xe0, 0xe4,
2406                         0,       0,    0,    0
2407                    };
2408         int     i;
2409
2410         for (i = 0; i < 40; i+=4) {
2411                 kprintf("%s: Reg:value : \t%x:%x \t%x:%x \t %x:%x \t %x:%x\n",
2412                        bktr_name(bktr),
2413                        r[i], INL(bktr, r[i]),
2414                        r[i+1], INL(bktr, r[i+1]),
2415                        r[i+2], INL(bktr, r[i+2]),
2416                        r[i+3], INL(bktr, r[i+3]));
2417         }
2418
2419         kprintf("%s: INT STAT %x \n", bktr_name(bktr),
2420                INL(bktr, BKTR_INT_STAT));
2421         kprintf("%s: Reg INT_MASK %x \n", bktr_name(bktr),
2422                INL(bktr, BKTR_INT_MASK));
2423         kprintf("%s: Reg GPIO_DMA_CTL %x \n", bktr_name(bktr),
2424                INW(bktr, BKTR_GPIO_DMA_CTL));
2425
2426         return( 0 );
2427 }
2428
2429 #endif
2430
2431 /*
2432  * build write instruction
2433  */
2434 #define BKTR_FM1      0x6       /* packed data to follow */
2435 #define BKTR_FM3      0xe       /* planar data to follow */
2436 #define BKTR_VRE      0x4       /* Marks the end of the even field */
2437 #define BKTR_VRO      0xC       /* Marks the end of the odd field */
2438 #define BKTR_PXV      0x0       /* valid word (never used) */
2439 #define BKTR_EOL      0x1       /* last dword, 4 bytes */
2440 #define BKTR_SOL      0x2       /* first dword */
2441
2442 #define OP_WRITE      (0x1 << 28)
2443 #define OP_SKIP       (0x2 << 28)
2444 #define OP_WRITEC     (0x5 << 28)
2445 #define OP_JUMP       (0x7 << 28)
2446 #define OP_SYNC       (0x8 << 28)
2447 #define OP_WRITE123   (0x9 << 28)
2448 #define OP_WRITES123  (0xb << 28)
2449 #define OP_SOL        (1 << 27)         /* first instr for scanline */
2450 #define OP_EOL        (1 << 26)
2451
2452 #define BKTR_RESYNC   (1 << 15)
2453 #define BKTR_GEN_IRQ  (1 << 24)
2454
2455 /*
2456  * The RISC status bits can be set/cleared in the RISC programs
2457  * and tested in the Interrupt Handler
2458  */
2459 #define BKTR_SET_RISC_STATUS_BIT0 (1 << 16)
2460 #define BKTR_SET_RISC_STATUS_BIT1 (1 << 17)
2461 #define BKTR_SET_RISC_STATUS_BIT2 (1 << 18)
2462 #define BKTR_SET_RISC_STATUS_BIT3 (1 << 19)
2463
2464 #define BKTR_CLEAR_RISC_STATUS_BIT0 (1 << 20)
2465 #define BKTR_CLEAR_RISC_STATUS_BIT1 (1 << 21)
2466 #define BKTR_CLEAR_RISC_STATUS_BIT2 (1 << 22)
2467 #define BKTR_CLEAR_RISC_STATUS_BIT3 (1 << 23)
2468
2469 #define BKTR_TEST_RISC_STATUS_BIT0 (1 << 28)
2470 #define BKTR_TEST_RISC_STATUS_BIT1 (1 << 29)
2471 #define BKTR_TEST_RISC_STATUS_BIT2 (1 << 30)
2472 #define BKTR_TEST_RISC_STATUS_BIT3 (1 << 31)
2473
2474 static bool_t notclipped (bktr_reg_t * bktr, int x, int width) {
2475     int i;
2476     bktr_clip_t * clip_node;
2477     bktr->clip_start = -1;
2478     bktr->last_y = 0;
2479     bktr->y = 0;
2480     bktr->y2 = width;
2481     bktr->line_length = width;
2482     bktr->yclip = -1;
2483     bktr->yclip2 = -1;
2484     bktr->current_col = 0;
2485
2486     if (bktr->max_clip_node == 0 ) return TRUE;
2487     clip_node = (bktr_clip_t *) &bktr->clip_list[0];
2488
2489
2490     for (i = 0; i < bktr->max_clip_node; i++ ) {
2491         clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2492         if (x >= clip_node->x_min && x <= clip_node->x_max  ) {
2493             bktr->clip_start = i;
2494             return FALSE;
2495         }
2496     }
2497
2498     return TRUE;
2499 }
2500
2501 static bool_t getline(bktr_reg_t *bktr, int x ) {
2502     int i, j;
2503     bktr_clip_t * clip_node ;
2504
2505     if (bktr->line_length == 0 ||
2506         bktr->current_col >= bktr->line_length) return FALSE;
2507
2508     bktr->y = min(bktr->last_y, bktr->line_length);
2509     bktr->y2 = bktr->line_length;
2510
2511     bktr->yclip = bktr->yclip2 = -1;
2512     for (i = bktr->clip_start; i < bktr->max_clip_node; i++ ) {
2513         clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2514         if (x >= clip_node->x_min && x <= clip_node->x_max) {
2515             if (bktr->last_y <= clip_node->y_min) {
2516                 bktr->y =      min(bktr->last_y, bktr->line_length);
2517                 bktr->y2 =     min(clip_node->y_min, bktr->line_length);
2518                 bktr->yclip =  min(clip_node->y_min, bktr->line_length);
2519                 bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
2520                 bktr->last_y = bktr->yclip2;
2521                 bktr->clip_start = i;
2522
2523                 for (j = i+1; j  < bktr->max_clip_node; j++ ) {
2524                     clip_node = (bktr_clip_t *) &bktr->clip_list[j];
2525                     if (x >= clip_node->x_min && x <= clip_node->x_max) {
2526                         if (bktr->last_y >= clip_node->y_min) {
2527                             bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
2528                             bktr->last_y = bktr->yclip2;
2529                             bktr->clip_start = j;
2530                         }
2531                     } else break  ;
2532                 }
2533                 return TRUE;
2534             }
2535         }
2536     }
2537
2538     if (bktr->current_col <= bktr->line_length) {
2539         bktr->current_col = bktr->line_length;
2540         return TRUE;
2541     }
2542     return FALSE;
2543 }
2544
2545 static bool_t split(bktr_reg_t * bktr, volatile uint32_t **dma_prog, int width ,
2546                     u_long operation, int pixel_width,
2547                     volatile u_char ** target_buffer, int cols ) {
2548
2549  u_long flag, flag2;
2550  struct meteor_pixfmt *pf = &pixfmt_table[ bktr->pixfmt ].public;
2551  u_int  skip, start_skip;
2552
2553   /*  For RGB24, we need to align the component in FIFO Byte Lane 0         */
2554   /*    to the 1st byte in the mem dword containing our start addr.         */
2555   /*    BTW, we know this pixfmt's 1st byte is Blue; thus the start addr    */
2556   /*     must be Blue.                                                      */
2557   start_skip = 0;
2558   if (( pf->type == METEOR_PIXTYPE_RGB ) && ( pf->Bpp == 3 ))
2559           switch ( ((uintptr_t) (volatile void *) *target_buffer) % 4 ) {
2560           case 2 : start_skip = 4 ; break;
2561           case 1 : start_skip = 8 ; break;
2562           }
2563
2564  if ((width * pixel_width) < DMA_BT848_SPLIT ) {
2565      if (  width == cols) {
2566          flag = OP_SOL | OP_EOL;
2567        } else if (bktr->current_col == 0 ) {
2568             flag  = OP_SOL;
2569        } else if (bktr->current_col == cols) {
2570             flag = OP_EOL;
2571        } else flag = 0;
2572
2573      skip = 0;
2574      if (( flag & OP_SOL ) && ( start_skip > 0 )) {
2575              *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip;
2576              flag &= ~OP_SOL;
2577              skip = start_skip;
2578      }
2579
2580      *(*dma_prog)++ = operation | flag  | (width * pixel_width - skip);
2581      if (operation != OP_SKIP )
2582          *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer;
2583
2584      *target_buffer += width * pixel_width;
2585      bktr->current_col += width;
2586
2587  } else {
2588
2589         if (bktr->current_col == 0 && width == cols) {
2590             flag = OP_SOL ;
2591             flag2 = OP_EOL;
2592         } else if (bktr->current_col == 0 ) {
2593             flag = OP_SOL;
2594             flag2 = 0;
2595         } else if (bktr->current_col >= cols)  {
2596             flag =  0;
2597             flag2 = OP_EOL;
2598         } else {
2599             flag =  0;
2600             flag2 = 0;
2601         }
2602
2603         skip = 0;
2604         if (( flag & OP_SOL ) && ( start_skip > 0 )) {
2605                 *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip;
2606                 flag &= ~OP_SOL;
2607                 skip = start_skip;
2608         }
2609
2610         *(*dma_prog)++ = operation  | flag |
2611               (width * pixel_width / 2 - skip);
2612         if (operation != OP_SKIP )
2613               *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer ;
2614         *target_buffer +=  (width * pixel_width / 2) ;
2615
2616         if ( operation == OP_WRITE )
2617                 operation = OP_WRITEC;
2618         *(*dma_prog)++ = operation | flag2 |
2619             (width * pixel_width / 2);
2620         *target_buffer +=  (width * pixel_width / 2) ;
2621           bktr->current_col += width;
2622
2623     }
2624  return TRUE;
2625 }
2626
2627
2628 /*
2629  * Generate the RISC instructions to capture both VBI and video images
2630  */
2631 static void
2632 rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
2633 {
2634         int                     i;
2635         volatile uint32_t       target_buffer, buffer, target,width;
2636         volatile uint32_t       pitch;
2637         volatile uint32_t       *dma_prog;      /* DMA prog is an array of
2638                                                 32 bit RISC instructions */
2639         volatile uint32_t       *loop_point;
2640         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2641         u_int                   Bpp = pf_int->public.Bpp;
2642         unsigned int            vbisamples;     /* VBI samples per line */
2643         unsigned int            vbilines;       /* VBI lines per field */
2644         unsigned int            num_dwords;     /* DWORDS per line */
2645
2646         vbisamples = format_params[bktr->format_params].vbi_num_samples;
2647         vbilines   = format_params[bktr->format_params].vbi_num_lines;
2648         num_dwords = vbisamples/4;
2649
2650         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2651         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2652         OUTB(bktr, BKTR_VBI_PACK_SIZE, ((num_dwords)) & 0xff);
2653         OUTB(bktr, BKTR_VBI_PACK_DEL, ((num_dwords)>> 8) & 0x01); /* no hdelay    */
2654                                                             /* no ext frame */
2655
2656         OUTB(bktr, BKTR_OFORM, 0x00);
2657
2658         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2659         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2660         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2661         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2662
2663         /* disable gamma correction removal */
2664         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2665
2666         if (cols > 385 ) {
2667             OUTB(bktr, BKTR_E_VTC, 0);
2668             OUTB(bktr, BKTR_O_VTC, 0);
2669         } else {
2670             OUTB(bktr, BKTR_E_VTC, 1);
2671             OUTB(bktr, BKTR_O_VTC, 1);
2672         }
2673         bktr->capcontrol = 3 << 2 |  3;
2674
2675         dma_prog = (uint32_t *) bktr->dma_prog;
2676
2677         /* Construct Write */
2678
2679         if (bktr->video.addr) {
2680                 target_buffer = (u_long) bktr->video.addr;
2681                 pitch = bktr->video.width;
2682         }
2683         else {
2684                 target_buffer = (u_long) vtophys(bktr->bigbuf);
2685                 pitch = cols*Bpp;
2686         }
2687
2688         buffer = target_buffer;
2689
2690         /* Wait for the VRE sync marking the end of the Even and
2691          * the start of the Odd field. Resync here.
2692          */
2693         *dma_prog++ = OP_SYNC | BKTR_RESYNC |BKTR_VRE;
2694         *dma_prog++ = 0;
2695
2696         loop_point = dma_prog;
2697
2698         /* store the VBI data */
2699         /* look for sync with packed data */
2700         *dma_prog++ = OP_SYNC | BKTR_FM1;
2701         *dma_prog++ = 0;
2702         for(i = 0; i < vbilines; i++) {
2703                 *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples;
2704                 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
2705                                         (i * VBI_LINE_SIZE));
2706         }
2707
2708         if ( (i_flag == 2/*Odd*/) || (i_flag==3) /*interlaced*/ ) {
2709                 /* store the Odd field video image */
2710                 /* look for sync with packed data */
2711                 *dma_prog++ = OP_SYNC  | BKTR_FM1;
2712                 *dma_prog++ = 0;  /* NULL WORD */
2713                 width = cols;
2714                 for (i = 0; i < (rows/interlace); i++) {
2715                     target = target_buffer;
2716                     if ( notclipped(bktr, i, width)) {
2717                         split(bktr, &dma_prog, bktr->y2 - bktr->y, OP_WRITE,
2718                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2719
2720                     } else {
2721                         while(getline(bktr, i)) {
2722                             if (bktr->y != bktr->y2 ) {
2723                                 split(bktr, &dma_prog,
2724                                       bktr->y2 - bktr->y, OP_WRITE,
2725                                       Bpp, (volatile u_char **)(uintptr_t)&target, cols);
2726                             }
2727                             if (bktr->yclip != bktr->yclip2 ) {
2728                                 split(bktr,&dma_prog,
2729                                       bktr->yclip2 - bktr->yclip,
2730                                       OP_SKIP,
2731                                       Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2732                             }
2733                         }
2734
2735                     }
2736
2737                     target_buffer += interlace * pitch;
2738
2739                 }
2740
2741         } /* end if */
2742
2743         /* Grab the Even field */
2744         /* Look for the VRO, end of Odd field, marker */
2745         *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
2746         *dma_prog++ = 0;  /* NULL WORD */
2747
2748         /* store the VBI data */
2749         /* look for sync with packed data */
2750         *dma_prog++ = OP_SYNC | BKTR_FM1;
2751         *dma_prog++ = 0;
2752         for(i = 0; i < vbilines; i++) {
2753                 *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples;
2754                 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
2755                                 ((i+MAX_VBI_LINES) * VBI_LINE_SIZE));
2756         }
2757
2758         /* store the video image */
2759         if (i_flag == 1) /*Even Only*/
2760                 target_buffer = buffer;
2761         if (i_flag == 3) /*interlaced*/
2762                 target_buffer = buffer+pitch;
2763
2764
2765         if ((i_flag == 1) /*Even Only*/ || (i_flag==3) /*interlaced*/) {
2766                 /* look for sync with packed data */
2767                 *dma_prog++ = OP_SYNC | BKTR_FM1;
2768                 *dma_prog++ = 0;  /* NULL WORD */
2769                 width = cols;
2770                 for (i = 0; i < (rows/interlace); i++) {
2771                     target = target_buffer;
2772                     if ( notclipped(bktr, i, width)) {
2773                         split(bktr, &dma_prog, bktr->y2 - bktr->y, OP_WRITE,
2774                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2775                     } else {
2776                         while(getline(bktr, i)) {
2777                             if (bktr->y != bktr->y2 ) {
2778                                 split(bktr, &dma_prog,
2779                                       bktr->y2 - bktr->y, OP_WRITE,
2780                                       Bpp, (volatile u_char **)(uintptr_t)&target,
2781                                       cols);
2782                             }
2783                             if (bktr->yclip != bktr->yclip2 ) {
2784                                 split(bktr, &dma_prog,
2785                                       bktr->yclip2 - bktr->yclip, OP_SKIP,
2786                                       Bpp, (volatile u_char **)(uintptr_t) &target,  cols);
2787                             }
2788
2789                         }
2790
2791                     }
2792
2793                     target_buffer += interlace * pitch;
2794
2795                 }
2796         }
2797
2798         /* Look for end of 'Even Field' */
2799         *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE;
2800         *dma_prog++ = 0;  /* NULL WORD */
2801
2802         *dma_prog++ = OP_JUMP ;
2803         *dma_prog++ = (u_long ) vtophys(loop_point) ;
2804         *dma_prog++ = 0;  /* NULL WORD */
2805
2806 }
2807
2808
2809
2810
2811 static void
2812 rgb_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
2813 {
2814         int                     i;
2815         volatile uint32_t               target_buffer, buffer, target,width;
2816         volatile uint32_t       pitch;
2817         volatile  uint32_t      *dma_prog;
2818         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2819         u_int                   Bpp = pf_int->public.Bpp;
2820
2821         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2822         OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
2823         OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
2824         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2825
2826         OUTB(bktr, BKTR_OFORM, 0x00);
2827
2828         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2829         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2830         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2831         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2832
2833         /* disable gamma correction removal */
2834         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2835
2836         if (cols > 385 ) {
2837             OUTB(bktr, BKTR_E_VTC, 0);
2838             OUTB(bktr, BKTR_O_VTC, 0);
2839         } else {
2840             OUTB(bktr, BKTR_E_VTC, 1);
2841             OUTB(bktr, BKTR_O_VTC, 1);
2842         }
2843         bktr->capcontrol = 3 << 2 |  3;
2844
2845         dma_prog = (uint32_t *) bktr->dma_prog;
2846
2847         /* Construct Write */
2848
2849         if (bktr->video.addr) {
2850                 target_buffer = (uint32_t) bktr->video.addr;
2851                 pitch = bktr->video.width;
2852         }
2853         else {
2854                 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
2855                 pitch = cols*Bpp;
2856         }
2857
2858         buffer = target_buffer;
2859
2860         /* contruct sync : for video packet format */
2861         *dma_prog++ = OP_SYNC  | BKTR_RESYNC | BKTR_FM1;
2862
2863         /* sync, mode indicator packed data */
2864         *dma_prog++ = 0;  /* NULL WORD */
2865         width = cols;
2866         for (i = 0; i < (rows/interlace); i++) {
2867             target = target_buffer;
2868             if ( notclipped(bktr, i, width)) {
2869                 split(bktr, &dma_prog,
2870                       bktr->y2 - bktr->y, OP_WRITE,
2871                       Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2872
2873             } else {
2874                 while(getline(bktr, i)) {
2875                     if (bktr->y != bktr->y2 ) {
2876                         split(bktr, &dma_prog,
2877                               bktr->y2 - bktr->y, OP_WRITE,
2878                               Bpp, (volatile u_char **)(uintptr_t)&target, cols);
2879                     }
2880                     if (bktr->yclip != bktr->yclip2 ) {
2881                         split(bktr,&dma_prog,
2882                               bktr->yclip2 - bktr->yclip,
2883                               OP_SKIP,
2884                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2885                     }
2886                 }
2887
2888             }
2889
2890             target_buffer += interlace * pitch;
2891
2892         }
2893
2894         switch (i_flag) {
2895         case 1:
2896                 /* sync vre */
2897                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO;
2898                 *dma_prog++ = 0;  /* NULL WORD */
2899
2900                 *dma_prog++ = OP_JUMP;
2901                 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog);
2902                 return;
2903
2904         case 2:
2905                 /* sync vro */
2906                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE;
2907                 *dma_prog++ = 0;  /* NULL WORD */
2908
2909                 *dma_prog++ = OP_JUMP;
2910                 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog);
2911                 return;
2912
2913         case 3:
2914                 /* sync vro */
2915                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
2916                 *dma_prog++ = 0;  /* NULL WORD */
2917                 *dma_prog++ = OP_JUMP;
2918                 *dma_prog = (uint32_t ) vtophys(bktr->odd_dma_prog);
2919                 break;
2920         }
2921
2922         if (interlace == 2) {
2923
2924                 target_buffer = buffer + pitch;
2925
2926                 dma_prog = (uint32_t *) bktr->odd_dma_prog;
2927
2928                 /* sync vre IRQ bit */
2929                 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1;
2930                 *dma_prog++ = 0;  /* NULL WORD */
2931                 width = cols;
2932                 for (i = 0; i < (rows/interlace); i++) {
2933                     target = target_buffer;
2934                     if ( notclipped(bktr, i, width)) {
2935                         split(bktr, &dma_prog,
2936                               bktr->y2 - bktr->y, OP_WRITE,
2937                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2938                     } else {
2939                         while(getline(bktr, i)) {
2940                             if (bktr->y != bktr->y2 ) {
2941                                 split(bktr, &dma_prog,
2942                                       bktr->y2 - bktr->y, OP_WRITE,
2943                                       Bpp, (volatile u_char **)(uintptr_t)&target,
2944                                       cols);
2945                             }
2946                             if (bktr->yclip != bktr->yclip2 ) {
2947                                 split(bktr, &dma_prog,
2948                                       bktr->yclip2 - bktr->yclip, OP_SKIP,
2949                                       Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2950                             }
2951
2952                         }
2953
2954                     }
2955
2956                     target_buffer += interlace * pitch;
2957
2958                 }
2959         }
2960
2961         /* sync vre IRQ bit */
2962         *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE;
2963         *dma_prog++ = 0;  /* NULL WORD */
2964         *dma_prog++ = OP_JUMP ;
2965         *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog) ;
2966         *dma_prog++ = 0;  /* NULL WORD */
2967 }
2968
2969
2970 /*
2971  *
2972  */
2973 static void
2974 yuvpack_prog( bktr_ptr_t bktr, char i_flag,
2975               int cols, int rows, int interlace )
2976 {
2977         int                     i;
2978         volatile unsigned int   inst;
2979         volatile unsigned int   inst3;
2980         volatile uint32_t       target_buffer, buffer;
2981         volatile  uint32_t      *dma_prog;
2982         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2983         int                     b;
2984
2985         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2986
2987         OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* enable chroma comb */
2988         OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
2989
2990         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_RGB_DED | BT848_COLOR_CTL_GAMMA);
2991         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2992
2993         bktr->capcontrol = 3 << 2 |  3;
2994
2995         dma_prog = (uint32_t *) bktr->dma_prog;
2996
2997         /* Construct Write */
2998
2999         /* write , sol, eol */
3000         inst = OP_WRITE  | OP_SOL | (cols);
3001         /* write , sol, eol */
3002         inst3 = OP_WRITE | OP_EOL | (cols);
3003
3004         if (bktr->video.addr)
3005                 target_buffer = (uint32_t) bktr->video.addr;
3006         else
3007                 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3008
3009         buffer = target_buffer;
3010
3011         /* contruct sync : for video packet format */
3012         /* sync, mode indicator packed data */
3013         *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1;
3014         *dma_prog++ = 0;  /* NULL WORD */
3015
3016         b = cols;
3017
3018         for (i = 0; i < (rows/interlace); i++) {
3019                 *dma_prog++ = inst;
3020                 *dma_prog++ = target_buffer;
3021                 *dma_prog++ = inst3;
3022                 *dma_prog++ = target_buffer + b;
3023                 target_buffer += interlace*(cols * 2);
3024         }
3025
3026         switch (i_flag) {
3027         case 1:
3028                 /* sync vre */
3029                 *dma_prog++ = OP_SYNC  | BKTR_GEN_IRQ | BKTR_VRE;
3030                 *dma_prog++ = 0;  /* NULL WORD */
3031
3032                 *dma_prog++ = OP_JUMP;
3033                 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3034                 return;
3035
3036         case 2:
3037                 /* sync vro */
3038                 *dma_prog++ = OP_SYNC  | BKTR_GEN_IRQ | BKTR_VRO;
3039                 *dma_prog++ = 0;  /* NULL WORD */
3040                 *dma_prog++ = OP_JUMP;
3041                 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3042                 return;
3043
3044         case 3:
3045                 /* sync vro */
3046                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
3047                 *dma_prog++ = 0;  /* NULL WORD */
3048                 *dma_prog++ = OP_JUMP  ;
3049                 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog);
3050                 break;
3051         }
3052
3053         if (interlace == 2) {
3054
3055                 target_buffer =  (uint32_t) buffer + cols*2;
3056
3057                 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3058
3059                 /* sync vre */
3060                 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1;
3061                 *dma_prog++ = 0;  /* NULL WORD */
3062
3063                 for (i = 0; i < (rows/interlace) ; i++) {
3064                         *dma_prog++ = inst;
3065                         *dma_prog++ = target_buffer;
3066                         *dma_prog++ = inst3;
3067                         *dma_prog++ = target_buffer + b;
3068                         target_buffer += interlace * ( cols*2);
3069                 }
3070         }
3071
3072         /* sync vro IRQ bit */
3073         *dma_prog++ = OP_SYNC   |  BKTR_GEN_IRQ  | BKTR_RESYNC |  BKTR_VRE;
3074         *dma_prog++ = 0;  /* NULL WORD */
3075         *dma_prog++ = OP_JUMP ;
3076         *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3077
3078         *dma_prog++ = OP_JUMP;
3079         *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3080         *dma_prog++ = 0;  /* NULL WORD */
3081 }
3082
3083
3084 /*
3085  *
3086  */
3087 static void
3088 yuv422_prog( bktr_ptr_t bktr, char i_flag,
3089              int cols, int rows, int interlace ){
3090
3091         int                     i;
3092         volatile unsigned int   inst;
3093         volatile uint32_t       target_buffer, t1, buffer;
3094         volatile uint32_t       *dma_prog;
3095         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3096
3097         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3098
3099         dma_prog = (uint32_t*) bktr->dma_prog;
3100
3101         bktr->capcontrol =   1 << 6 | 1 << 4 |  3;
3102
3103         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3104         OUTB(bktr, BKTR_OFORM, 0x00);
3105
3106         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_LDEC); /* disable luma decimation */
3107         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_LDEC);
3108
3109         OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC);      /* chroma agc enable */
3110         OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
3111
3112         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
3113         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
3114         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
3115         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
3116
3117         /* disable gamma correction removal */
3118         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
3119
3120         /* Construct Write */
3121         inst  = OP_WRITE123  | OP_SOL | OP_EOL |  (cols);
3122         if (bktr->video.addr)
3123                 target_buffer = (uint32_t) bktr->video.addr;
3124         else
3125                 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3126
3127         buffer = target_buffer;
3128
3129         t1 = buffer;
3130
3131         /* contruct sync : for video packet format */
3132         *dma_prog++ = OP_SYNC  | 1 << 15 |      BKTR_FM3; /*sync, mode indicator packed data*/
3133         *dma_prog++ = 0;  /* NULL WORD */
3134
3135         for (i = 0; i < (rows/interlace ) ; i++) {
3136                 *dma_prog++ = inst;
3137                 *dma_prog++ = cols/2 | cols/2 << 16;
3138                 *dma_prog++ = target_buffer;
3139                 *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
3140                 *dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace;
3141                 target_buffer += interlace*cols;
3142         }
3143
3144         switch (i_flag) {
3145         case 1:
3146                 *dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRE;  /*sync vre*/
3147                 *dma_prog++ = 0;  /* NULL WORD */
3148
3149                 *dma_prog++ = OP_JUMP ;
3150                 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3151                 return;
3152
3153         case 2:
3154                 *dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRO;  /*sync vre*/
3155                 *dma_prog++ = 0;  /* NULL WORD */
3156
3157                 *dma_prog++ = OP_JUMP;
3158                 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3159                 return;
3160
3161         case 3:
3162                 *dma_prog++ = OP_SYNC   | 1 << 24 |  1 << 15 |   BKTR_VRO;
3163                 *dma_prog++ = 0;  /* NULL WORD */
3164
3165                 *dma_prog++ = OP_JUMP  ;
3166                 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog);
3167                 break;
3168         }
3169
3170         if (interlace == 2) {
3171
3172                 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3173
3174                 target_buffer  = (uint32_t) buffer + cols;
3175                 t1 = buffer + cols/2;
3176                 *dma_prog++ = OP_SYNC   |   1 << 15 | BKTR_FM3;
3177                 *dma_prog++ = 0;  /* NULL WORD */
3178
3179                 for (i = 0; i < (rows/interlace )  ; i++) {
3180                         *dma_prog++ = inst;
3181                         *dma_prog++ = cols/2 | cols/2 << 16;
3182                         *dma_prog++ = target_buffer;
3183                         *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
3184                         *dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace;
3185                         target_buffer += interlace*cols;
3186                 }
3187         }
3188
3189         *dma_prog++ = OP_SYNC  | 1 << 24 | 1 << 15 |   BKTR_VRE;
3190         *dma_prog++ = 0;  /* NULL WORD */
3191         *dma_prog++ = OP_JUMP ;
3192         *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog) ;
3193         *dma_prog++ = 0;  /* NULL WORD */
3194 }
3195
3196
3197 /*
3198  *
3199  */
3200 static void
3201 yuv12_prog( bktr_ptr_t bktr, char i_flag,
3202              int cols, int rows, int interlace ){
3203
3204         int                     i;
3205         volatile unsigned int   inst;
3206         volatile unsigned int   inst1;
3207         volatile uint32_t       target_buffer, t1, buffer;
3208         volatile uint32_t       *dma_prog;
3209         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3210
3211         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3212
3213         dma_prog = (uint32_t *) bktr->dma_prog;
3214
3215         bktr->capcontrol =   1 << 6 | 1 << 4 |  3;
3216
3217         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3218         OUTB(bktr, BKTR_OFORM, 0x0);
3219
3220         /* Construct Write */
3221         inst  = OP_WRITE123  | OP_SOL | OP_EOL |  (cols);
3222         inst1  = OP_WRITES123  | OP_SOL | OP_EOL |  (cols);
3223         if (bktr->video.addr)
3224                 target_buffer = (uint32_t) bktr->video.addr;
3225         else
3226                 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
3227
3228         buffer = target_buffer;
3229         t1 = buffer;
3230
3231         *dma_prog++ = OP_SYNC  | 1 << 15 |      BKTR_FM3; /*sync, mode indicator packed data*/
3232         *dma_prog++ = 0;  /* NULL WORD */
3233
3234         for (i = 0; i < (rows/interlace )/2 ; i++) {
3235                 *dma_prog++ = inst;
3236                 *dma_prog++ = cols/2 | (cols/2 << 16);
3237                 *dma_prog++ = target_buffer;
3238                 *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
3239                 *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace;
3240                 target_buffer += interlace*cols;
3241                 *dma_prog++ = inst1;
3242                 *dma_prog++ = cols/2 | (cols/2 << 16);
3243                 *dma_prog++ = target_buffer;
3244                 target_buffer += interlace*cols;
3245
3246         }
3247
3248         switch (i_flag) {
3249         case 1:
3250                 *dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRE;  /*sync vre*/
3251                 *dma_prog++ = 0;  /* NULL WORD */
3252
3253                 *dma_prog++ = OP_JUMP;
3254                 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3255                 return;
3256
3257         case 2:
3258                 *dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRO;  /*sync vro*/
3259                 *dma_prog++ = 0;  /* NULL WORD */
3260
3261                 *dma_prog++ = OP_JUMP;
3262                 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3263                 return;
3264
3265         case 3:
3266                 *dma_prog++ = OP_SYNC |  1 << 24 | 1 << 15 | BKTR_VRO;
3267                 *dma_prog++ = 0;  /* NULL WORD */
3268                 *dma_prog++ = OP_JUMP ;
3269                 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog);
3270                 break;
3271         }
3272
3273         if (interlace == 2) {
3274
3275                 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3276
3277                 target_buffer  = (uint32_t) buffer + cols;
3278                 t1 = buffer + cols/2;
3279                 *dma_prog++ = OP_SYNC   | 1 << 15 | BKTR_FM3;
3280                 *dma_prog++ = 0;  /* NULL WORD */
3281
3282                 for (i = 0; i < ((rows/interlace )/2 ) ; i++) {
3283                     *dma_prog++ = inst;
3284                     *dma_prog++ = cols/2 | (cols/2 << 16);
3285                     *dma_prog++ = target_buffer;
3286                     *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
3287                     *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace;
3288                     target_buffer += interlace*cols;
3289                     *dma_prog++ = inst1;
3290                     *dma_prog++ = cols/2 | (cols/2 << 16);
3291                     *dma_prog++ = target_buffer;
3292                     target_buffer += interlace*cols;
3293
3294                 }
3295
3296
3297         }
3298
3299         *dma_prog++ = OP_SYNC |  1 << 24 | 1 << 15 | BKTR_VRE;
3300         *dma_prog++ = 0;  /* NULL WORD */
3301         *dma_prog++ = OP_JUMP;
3302         *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog);
3303         *dma_prog++ = 0;  /* NULL WORD */
3304 }
3305
3306
3307
3308 /*
3309  *
3310  */
3311 static void
3312 build_dma_prog( bktr_ptr_t bktr, char i_flag )
3313 {
3314         int                     rows, cols,  interlace;
3315         int                     tmp_int;
3316         unsigned int            temp;
3317         struct format_params    *fp;
3318         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3319
3320
3321         fp = &format_params[bktr->format_params];
3322
3323         OUTL(bktr, BKTR_INT_MASK,  ALL_INTS_DISABLED);
3324
3325         /* disable FIFO & RISC, leave other bits alone */
3326         OUTW(bktr, BKTR_GPIO_DMA_CTL, INW(bktr, BKTR_GPIO_DMA_CTL) & ~FIFO_RISC_ENABLED);
3327
3328         /* set video parameters */
3329         if (bktr->capture_area_enabled)
3330           temp = ((quad_t ) fp->htotal* (quad_t) bktr->capture_area_x_size * 4096
3331                   / fp->scaled_htotal / bktr->cols) -  4096;
3332         else
3333           temp = ((quad_t ) fp->htotal* (quad_t) fp->scaled_hactive * 4096
3334                   / fp->scaled_htotal / bktr->cols) -  4096;
3335
3336         /* kprintf("%s: HSCALE value is %d\n", bktr_name(bktr), temp); */
3337         OUTB(bktr, BKTR_E_HSCALE_LO, temp & 0xff);
3338         OUTB(bktr, BKTR_O_HSCALE_LO, temp & 0xff);
3339         OUTB(bktr, BKTR_E_HSCALE_HI, (temp >> 8) & 0xff);
3340         OUTB(bktr, BKTR_O_HSCALE_HI, (temp >> 8) & 0xff);
3341
3342         /* horizontal active */
3343         temp = bktr->cols;
3344         /* kprintf("%s: HACTIVE value is %d\n", bktr_name(bktr), temp); */
3345         OUTB(bktr, BKTR_E_HACTIVE_LO, temp & 0xff);
3346         OUTB(bktr, BKTR_O_HACTIVE_LO, temp & 0xff);
3347         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x3);
3348         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x3);
3349         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 8) & 0x3));
3350         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 8) & 0x3));
3351
3352         /* horizontal delay */
3353         if (bktr->capture_area_enabled)
3354           temp = ( (fp->hdelay* fp->scaled_hactive + bktr->capture_area_x_offset* fp->scaled_htotal)
3355                  * bktr->cols) / (bktr->capture_area_x_size * fp->hactive);
3356         else
3357           temp = (fp->hdelay * bktr->cols) / fp->hactive;
3358
3359         temp = temp & 0x3fe;
3360
3361         /* kprintf("%s: HDELAY value is %d\n", bktr_name(bktr), temp); */
3362         OUTB(bktr, BKTR_E_DELAY_LO, temp & 0xff);
3363         OUTB(bktr, BKTR_O_DELAY_LO, temp & 0xff);
3364         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xc);
3365         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xc);
3366         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 6) & 0xc));
3367         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 6) & 0xc));
3368
3369         /* vertical scale */
3370
3371         if (bktr->capture_area_enabled) {
3372           if (bktr->flags  & METEOR_ONLY_ODD_FIELDS ||
3373               bktr->flags & METEOR_ONLY_EVEN_FIELDS)
3374             tmp_int = 65536 -
3375             (((bktr->capture_area_y_size  * 256 + (bktr->rows/2)) / bktr->rows) - 512);
3376           else {
3377             tmp_int = 65536 -
3378             (((bktr->capture_area_y_size * 512 + (bktr->rows / 2)) /  bktr->rows) - 512);
3379           }
3380         } else {
3381           if (bktr->flags  & METEOR_ONLY_ODD_FIELDS ||
3382               bktr->flags & METEOR_ONLY_EVEN_FIELDS)
3383             tmp_int = 65536 -
3384             (((fp->vactive  * 256 + (bktr->rows/2)) / bktr->rows) - 512);
3385           else {
3386             tmp_int = 65536  -
3387             (((fp->vactive * 512 + (bktr->rows / 2)) /  bktr->rows) - 512);
3388           }
3389         }
3390
3391         tmp_int &= 0x1fff;
3392         /* kprintf("%s: VSCALE value is %d\n", bktr_name(bktr), tmp_int); */
3393         OUTB(bktr, BKTR_E_VSCALE_LO, tmp_int & 0xff);
3394         OUTB(bktr, BKTR_O_VSCALE_LO, tmp_int & 0xff);
3395         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x1f);
3396         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x1f);
3397         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | ((tmp_int >> 8) & 0x1f));
3398         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | ((tmp_int >> 8) & 0x1f));
3399
3400
3401         /* vertical active */
3402         if (bktr->capture_area_enabled)
3403           temp = bktr->capture_area_y_size;
3404         else
3405           temp = fp->vactive;
3406         /* kprintf("%s: VACTIVE is %d\n", bktr_name(bktr), temp); */
3407         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x30);
3408         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 4) & 0x30));
3409         OUTB(bktr, BKTR_E_VACTIVE_LO, temp & 0xff);
3410         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x30);
3411         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 4) & 0x30));
3412         OUTB(bktr, BKTR_O_VACTIVE_LO, temp & 0xff);
3413
3414         /* vertical delay */
3415         if (bktr->capture_area_enabled)
3416           temp = fp->vdelay + (bktr->capture_area_y_offset);
3417         else
3418           temp = fp->vdelay;
3419         /* kprintf("%s: VDELAY is %d\n", bktr_name(bktr), temp); */
3420         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xC0);
3421         OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 2) & 0xC0));
3422         OUTB(bktr, BKTR_E_VDELAY_LO, temp & 0xff);
3423         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xC0);
3424         OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 2) & 0xC0));
3425         OUTB(bktr, BKTR_O_VDELAY_LO, temp & 0xff);
3426
3427         /* end of video params */
3428
3429         if ((bktr->xtal_pll_mode == BT848_USE_PLL)
3430            && (fp->iform_xtsel==BT848_IFORM_X_XT1)) {
3431                 OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_PLL); /* Select PLL mode */
3432         } else {
3433                 OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_XTAL); /* Select Normal xtal 0/xtal 1 mode */
3434         }
3435
3436         /* capture control */
3437         switch (i_flag) {
3438         case 1:
3439                 bktr->bktr_cap_ctl =
3440                     (BT848_CAP_CTL_DITH_FRAME | BT848_CAP_CTL_EVEN);
3441                 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20);
3442                 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20);
3443                 interlace = 1;
3444                 break;
3445          case 2:
3446                 bktr->bktr_cap_ctl =
3447                         (BT848_CAP_CTL_DITH_FRAME | BT848_CAP_CTL_ODD);
3448                 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20);
3449                 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20);
3450                 interlace = 1;
3451                 break;
3452          default:
3453                 bktr->bktr_cap_ctl =
3454                         (BT848_CAP_CTL_DITH_FRAME |
3455                          BT848_CAP_CTL_EVEN | BT848_CAP_CTL_ODD);
3456                 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x20);
3457                 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x20);
3458                 interlace = 2;
3459                 break;
3460         }
3461
3462         OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
3463
3464         rows = bktr->rows;
3465         cols = bktr->cols;
3466
3467         bktr->vbiflags &= ~VBI_CAPTURE; /* default - no vbi capture */
3468
3469         /* RGB Grabs. If /dev/vbi is already open, or we are a PAL/SECAM */
3470         /* user, then use the rgb_vbi RISC program. */
3471         /* Otherwise, use the normal rgb RISC program */
3472         if (pf_int->public.type == METEOR_PIXTYPE_RGB) {
3473                 if ( (bktr->vbiflags & VBI_OPEN)
3474                    ||(bktr->format_params == BT848_IFORM_F_PALBDGHI)
3475                    ||(bktr->format_params == BT848_IFORM_F_SECAM)
3476                    ){
3477                         bktr->bktr_cap_ctl |=
3478                                 BT848_CAP_CTL_VBI_EVEN | BT848_CAP_CTL_VBI_ODD;
3479                         bktr->vbiflags |= VBI_CAPTURE;
3480                         rgb_vbi_prog(bktr, i_flag, cols, rows, interlace);
3481                         return;
3482                 } else {
3483                         rgb_prog(bktr, i_flag, cols, rows, interlace);
3484                         return;
3485                 }
3486         }
3487
3488         if ( pf_int->public.type  == METEOR_PIXTYPE_YUV ) {
3489                 yuv422_prog(bktr, i_flag, cols, rows, interlace);
3490                 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3491                      | pixfmt_swap_flags( bktr->pixfmt ));
3492                 return;
3493         }
3494
3495         if ( pf_int->public.type  == METEOR_PIXTYPE_YUV_PACKED ) {
3496                 yuvpack_prog(bktr, i_flag, cols, rows, interlace);
3497                 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3498                      | pixfmt_swap_flags( bktr->pixfmt ));
3499                 return;
3500         }
3501
3502         if ( pf_int->public.type  == METEOR_PIXTYPE_YUV_12 ) {
3503                 yuv12_prog(bktr, i_flag, cols, rows, interlace);
3504                 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
3505                      | pixfmt_swap_flags( bktr->pixfmt ));
3506                 return;
3507         }
3508         return;
3509 }
3510
3511
3512 /******************************************************************************
3513  * video & video capture specific routines:
3514  */
3515
3516
3517 /*
3518  *
3519  */
3520 static void
3521 start_capture( bktr_ptr_t bktr, unsigned type )
3522 {
3523         u_char                  i_flag;
3524         struct format_params   *fp;
3525
3526         fp = &format_params[bktr->format_params];
3527
3528         /*  If requested, clear out capture buf first  */
3529         if (bktr->clr_on_start && (bktr->video.addr == 0)) {
3530                 bzero((caddr_t)bktr->bigbuf,
3531                       (size_t)bktr->rows * bktr->cols * bktr->frames *
3532                         pixfmt_table[ bktr->pixfmt ].public.Bpp);
3533         }
3534
3535         OUTB(bktr, BKTR_DSTATUS,  0);
3536         OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
3537
3538         bktr->flags |= type;
3539         bktr->flags &= ~METEOR_WANT_MASK;
3540         switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
3541         case METEOR_ONLY_EVEN_FIELDS:
3542                 bktr->flags |= METEOR_WANT_EVEN;
3543                 i_flag = 1;
3544                 break;
3545         case METEOR_ONLY_ODD_FIELDS:
3546                 bktr->flags |= METEOR_WANT_ODD;
3547                 i_flag = 2;
3548                 break;
3549         default:
3550                 bktr->flags |= METEOR_WANT_MASK;
3551                 i_flag = 3;
3552                 break;
3553         }
3554
3555         /*  TDEC is only valid for continuous captures  */
3556         if ( type == METEOR_SINGLE ) {
3557                 u_short fps_save = bktr->fps;
3558
3559                 set_fps(bktr, fp->frame_rate);
3560                 bktr->fps = fps_save;
3561         }
3562         else
3563                 set_fps(bktr, bktr->fps);
3564
3565         if (bktr->dma_prog_loaded == FALSE) {
3566                 build_dma_prog(bktr, i_flag);
3567                 bktr->dma_prog_loaded = TRUE;
3568         }
3569
3570
3571         OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
3572
3573 }
3574
3575
3576 /*
3577  *
3578  */
3579 static void
3580 set_fps( bktr_ptr_t bktr, u_short fps )
3581 {
3582         struct format_params    *fp;
3583         int i_flag;
3584
3585         fp = &format_params[bktr->format_params];
3586
3587         switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
3588         case METEOR_ONLY_EVEN_FIELDS:
3589                 bktr->flags |= METEOR_WANT_EVEN;
3590                 i_flag = 1;
3591                 break;
3592         case METEOR_ONLY_ODD_FIELDS:
3593                 bktr->flags |= METEOR_WANT_ODD;
3594                 i_flag = 1;
3595                 break;
3596         default:
3597                 bktr->flags |= METEOR_WANT_MASK;
3598                 i_flag = 2;
3599                 break;
3600         }
3601
3602         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
3603         OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
3604
3605         bktr->fps = fps;
3606         OUTB(bktr, BKTR_TDEC, 0);
3607
3608         if (fps < fp->frame_rate)
3609                 OUTB(bktr, BKTR_TDEC, i_flag*(fp->frame_rate - fps) & 0x3f);
3610         else
3611                 OUTB(bktr, BKTR_TDEC, 0);
3612         return;
3613
3614 }
3615
3616
3617
3618
3619
3620 /*
3621  * Given a pixfmt index, compute the bt848 swap_flags necessary to
3622  *   achieve the specified swapping.
3623  * Note that without bt swapping, 2Bpp and 3Bpp modes are written
3624  *   byte-swapped, and 4Bpp modes are byte and word swapped (see Table 6
3625  *   and read R->L).
3626  * Note also that for 3Bpp, we may additionally need to do some creative
3627  *   SKIPing to align the FIFO bytelines with the target buffer (see split()).
3628  * This is abstracted here: e.g. no swaps = RGBA; byte & short swap = ABGR
3629  *   as one would expect.
3630  */
3631
3632 static u_int pixfmt_swap_flags( int pixfmt )
3633 {
3634         struct meteor_pixfmt *pf = &pixfmt_table[ pixfmt ].public;
3635         u_int                 swapf = 0;
3636
3637         switch ( pf->Bpp ) {
3638         case 2 : swapf = ( pf->swap_bytes ? 0 : BSWAP );
3639                  break;
3640
3641         case 3 : /* no swaps supported for 3bpp - makes no sense w/ bt848 */
3642                  break;
3643
3644         case 4 : if ( pf->swap_bytes )
3645                         swapf = pf->swap_shorts ? 0 : WSWAP;
3646                  else
3647                         swapf = pf->swap_shorts ? BSWAP : (BSWAP | WSWAP);
3648                  break;
3649         }
3650         return swapf;
3651 }
3652
3653
3654
3655 /*
3656  * Converts meteor-defined pixel formats (e.g. METEOR_GEO_RGB16) into
3657  *   our pixfmt_table indices.
3658  */
3659
3660 static int oformat_meteor_to_bt( u_long format )
3661 {
3662         int    i;
3663         struct meteor_pixfmt *pf1, *pf2;
3664
3665         /*  Find format in compatibility table  */
3666         for ( i = 0; i < METEOR_PIXFMT_TABLE_SIZE; i++ )
3667                 if ( meteor_pixfmt_table[i].meteor_format == format )
3668                         break;
3669
3670         if ( i >= METEOR_PIXFMT_TABLE_SIZE )
3671                 return -1;
3672         pf1 = &meteor_pixfmt_table[i].public;
3673
3674         /*  Match it with an entry in master pixel format table  */
3675         for ( i = 0; i < PIXFMT_TABLE_SIZE; i++ ) {
3676                 pf2 = &pixfmt_table[i].public;
3677
3678                 if (( pf1->type        == pf2->type        ) &&
3679                     ( pf1->Bpp         == pf2->Bpp         ) &&
3680                     !bcmp( pf1->masks, pf2->masks, sizeof( pf1->masks )) &&
3681                     ( pf1->swap_bytes  == pf2->swap_bytes  ) &&
3682                     ( pf1->swap_shorts == pf2->swap_shorts ))
3683                         break;
3684         }
3685         if ( i >= PIXFMT_TABLE_SIZE )
3686                 return -1;
3687
3688         return i;
3689 }
3690
3691 /******************************************************************************
3692  * i2c primitives:
3693  */
3694
3695 /* */
3696 #define I2CBITTIME              (0x5<<4)        /* 5 * 0.48uS */
3697 #define I2CBITTIME_878              (1 << 7)
3698 #define I2C_READ                0x01
3699 #define I2C_COMMAND             (I2CBITTIME |                   \
3700                                  BT848_DATA_CTL_I2CSCL |        \
3701                                  BT848_DATA_CTL_I2CSDA)
3702
3703 #define I2C_COMMAND_878         (I2CBITTIME_878 |                       \
3704                                  BT848_DATA_CTL_I2CSCL |        \
3705                                  BT848_DATA_CTL_I2CSDA)
3706
3707 /* Select between old i2c code and new iicbus / smbus code */
3708 #if defined(BKTR_USE_FREEBSD_SMBUS)
3709
3710 /*
3711  * The hardware interface is actually SMB commands
3712  */
3713 int
3714 i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 )
3715 {
3716         char cmd;
3717
3718         if (bktr->id == BROOKTREE_848  ||
3719             bktr->id == BROOKTREE_848A ||
3720             bktr->id == BROOKTREE_849A)
3721                 cmd = I2C_COMMAND;
3722         else
3723                 cmd = I2C_COMMAND_878;
3724
3725         if (byte2 != -1) {
3726                 if (smbus_writew(bktr->i2c_sc.smbus, addr, cmd,
3727                         (short)(((byte2 & 0xff) << 8) | (byte1 & 0xff))))
3728                         return (-1);
3729         } else {
3730                 if (smbus_writeb(bktr->i2c_sc.smbus, addr, cmd,
3731                         (char)(byte1 & 0xff)))
3732                         return (-1);
3733         }
3734
3735         /* return OK */
3736         return( 0 );
3737 }
3738
3739 int
3740 i2cRead( bktr_ptr_t bktr, int addr )
3741 {
3742         char result;
3743         char cmd;
3744
3745         if (bktr->id == BROOKTREE_848  ||
3746             bktr->id == BROOKTREE_848A ||
3747             bktr->id == BROOKTREE_849A)
3748                 cmd = I2C_COMMAND;
3749         else
3750                 cmd = I2C_COMMAND_878;
3751
3752         if (smbus_readb(bktr->i2c_sc.smbus, addr, cmd, &result))
3753                 return (-1);
3754
3755         return ((int)((unsigned char)result));
3756 }
3757
3758 #define IICBUS(bktr) ((bktr)->i2c_sc.iicbb)
3759
3760 /* The MSP34xx and DPL35xx Audio chip require i2c bus writes of up */
3761 /* to 5 bytes which the bt848 automated i2c bus controller cannot handle */
3762 /* Therefore we need low level control of the i2c bus hardware */
3763
3764 /* Write to the MSP or DPL registers */
3765 void
3766 msp_dpl_write(bktr_ptr_t bktr, int i2c_addr,  unsigned char dev, unsigned int addr, unsigned int data)
3767 {
3768         unsigned char addr_l, addr_h, data_h, data_l ;
3769
3770         addr_h = (addr >>8) & 0xff;
3771         addr_l = addr & 0xff;
3772         data_h = (data >>8) & 0xff;
3773         data_l = data & 0xff;
3774
3775         iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3776
3777         iicbus_write_byte(IICBUS(bktr), dev, 0);
3778         iicbus_write_byte(IICBUS(bktr), addr_h, 0);
3779         iicbus_write_byte(IICBUS(bktr), addr_l, 0);
3780         iicbus_write_byte(IICBUS(bktr), data_h, 0);
3781         iicbus_write_byte(IICBUS(bktr), data_l, 0);
3782
3783         iicbus_stop(IICBUS(bktr));
3784
3785         return;
3786 }
3787
3788 /* Read from the MSP or DPL registers */
3789 unsigned int
3790 msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr)
3791 {
3792         unsigned int data;
3793         unsigned char addr_l, addr_h, dev_r;
3794         int read;
3795         u_char data_read[2];
3796
3797         addr_h = (addr >>8) & 0xff;
3798         addr_l = addr & 0xff;
3799         dev_r = dev+1;
3800
3801         /* XXX errors ignored */
3802         iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3803
3804         iicbus_write_byte(IICBUS(bktr), dev_r, 0);
3805         iicbus_write_byte(IICBUS(bktr), addr_h, 0);
3806         iicbus_write_byte(IICBUS(bktr), addr_l, 0);
3807
3808         iicbus_repeated_start(IICBUS(bktr), i2c_addr +1, 0 /* no timeout? */);
3809         iicbus_read(IICBUS(bktr), data_read, 2, &read, IIC_LAST_READ, 0);
3810         iicbus_stop(IICBUS(bktr));
3811
3812         data = (data_read[0]<<8) | data_read[1];
3813
3814         return (data);
3815 }
3816
3817 /* Reset the MSP or DPL chip */
3818 /* The user can block the reset (which is handy if you initialise the
3819  * MSP and/or DPL audio in another operating system first (eg in Windows)
3820  */
3821 void
3822 msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr )
3823 {
3824
3825 #ifndef BKTR_NO_MSP_RESET
3826         /* put into reset mode */
3827         iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3828         iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3829         iicbus_write_byte(IICBUS(bktr), 0x80, 0);
3830         iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3831         iicbus_stop(IICBUS(bktr));
3832
3833         /* put back to operational mode */
3834         iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
3835         iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3836         iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3837         iicbus_write_byte(IICBUS(bktr), 0x00, 0);
3838         iicbus_stop(IICBUS(bktr));
3839 #endif
3840         return;
3841 }
3842
3843 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
3844         int read;
3845
3846         /* XXX errors ignored */
3847         iicbus_start(IICBUS(bktr), bktr->remote_control_addr, 0 /* no timeout? */);
3848         iicbus_read(IICBUS(bktr),  remote->data, 3, &read, IIC_LAST_READ, 0);
3849         iicbus_stop(IICBUS(bktr));
3850
3851         return;
3852 }
3853
3854 #else /* defined(BKTR_USE_FREEBSD_SMBUS) */
3855
3856 /*
3857  * Program the i2c bus directly
3858  */
3859 int
3860 i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 )
3861 {
3862         u_long          x;
3863         u_long          data;
3864
3865         /* clear status bits */
3866         OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
3867
3868         /* build the command datum */
3869         if (bktr->id == BROOKTREE_848  ||
3870             bktr->id == BROOKTREE_848A ||
3871             bktr->id == BROOKTREE_849A) {
3872           data = ((addr & 0xff) << 24) | ((byte1 & 0xff) << 16) | I2C_COMMAND;
3873         } else {
3874           data = ((addr & 0xff) << 24) | ((byte1 & 0xff) << 16) | I2C_COMMAND_878;
3875         }
3876         if ( byte2 != -1 ) {
3877                 data |= ((byte2 & 0xff) << 8);
3878                 data |= BT848_DATA_CTL_I2CW3B;
3879         }
3880
3881         /* write the address and data */
3882         OUTL(bktr, BKTR_I2C_DATA_CTL, data);
3883
3884         /* wait for completion */
3885         for ( x = 0x7fffffff; x; --x ) {        /* safety valve */
3886                 if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE )
3887                         break;
3888         }
3889
3890         /* check for ACK */
3891         if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) )
3892                 return( -1 );
3893
3894         /* return OK */
3895         return( 0 );
3896 }
3897
3898
3899 /*
3900  *
3901  */
3902 int
3903 i2cRead( bktr_ptr_t bktr, int addr )
3904 {
3905         u_long          x;
3906
3907         /* clear status bits */
3908         OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
3909
3910         /* write the READ address */
3911         /* The Bt878 and Bt879  differed on the treatment of i2c commands */
3912
3913         if (bktr->id == BROOKTREE_848  ||
3914             bktr->id == BROOKTREE_848A ||
3915             bktr->id == BROOKTREE_849A) {
3916                 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND);
3917         } else {
3918                 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND_878);
3919         }
3920
3921         /* wait for completion */
3922         for ( x = 0x7fffffff; x; --x ) {        /* safety valve */
3923                 if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE )
3924                         break;
3925         }
3926
3927         /* check for ACK */
3928         if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) )
3929                 return( -1 );
3930
3931         /* it was a read */
3932         return( (INL(bktr, BKTR_I2C_DATA_CTL) >> 8) & 0xff );
3933 }
3934
3935 /* The MSP34xx Audio chip require i2c bus writes of up to 5 bytes which the */
3936 /* bt848 automated i2c bus controller cannot handle */
3937 /* Therefore we need low level control of the i2c bus hardware */
3938 /* Idea for the following functions are from elsewhere in this driver and */
3939 /* from the Linux BTTV i2c driver by Gerd Knorr <kraxel@cs.tu-berlin.de> */
3940
3941 #define BITD    40
3942 static void i2c_start( bktr_ptr_t bktr) {
3943         OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release data */
3944         OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release clock */
3945         OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* lower data */
3946         OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock */
3947 }
3948
3949 static void i2c_stop( bktr_ptr_t bktr) {
3950         OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock & data */
3951         OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* release clock */
3952         OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release data */
3953 }
3954
3955 static int i2c_write_byte( bktr_ptr_t bktr, unsigned char data) {
3956         int x;
3957         int status;
3958
3959         /* write out the byte */
3960         for ( x = 7; x >= 0; --x ) {
3961                 if ( data & (1<<x) ) {
3962                         OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
3963                         DELAY( BITD );          /* assert HI data */
3964                         OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
3965                         DELAY( BITD );          /* strobe clock */
3966                         OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
3967                         DELAY( BITD );          /* release clock */
3968                 }
3969                 else {
3970                         OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
3971                         DELAY( BITD );          /* assert LO data */
3972                         OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
3973                         DELAY( BITD );          /* strobe clock */
3974                         OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
3975                         DELAY( BITD );          /* release clock */
3976                 }
3977         }
3978
3979         /* look for an ACK */
3980         OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* float data */
3981         OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* strobe clock */
3982         status = INL(bktr, BKTR_I2C_DATA_CTL) & 1;       /* read the ACK bit */
3983         OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release clock */
3984
3985         return( status );
3986 }
3987
3988 static int i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last ) {
3989         int x;
3990         int bit;
3991         int byte = 0;
3992
3993         /* read in the byte */
3994         OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
3995         DELAY( BITD );                          /* float data */
3996         for ( x = 7; x >= 0; --x ) {
3997                 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
3998                 DELAY( BITD );                  /* strobe clock */
3999                 bit = INL(bktr, BKTR_I2C_DATA_CTL) & 1;  /* read the data bit */
4000                 if ( bit ) byte |= (1<<x);
4001                 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4002                 DELAY( BITD );                  /* release clock */
4003         }
4004         /* After reading the byte, send an ACK */
4005         /* (unless that was the last byte, for which we send a NAK */
4006         if (last) { /* send NAK - same a writing a 1 */
4007                 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4008                 DELAY( BITD );                  /* set data bit */
4009                 OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4010                 DELAY( BITD );                  /* strobe clock */
4011                 OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4012                 DELAY( BITD );                  /* release clock */
4013         } else { /* send ACK - same as writing a 0 */
4014                 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4015                 DELAY( BITD );                  /* set data bit */
4016                 OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4017                 DELAY( BITD );                  /* strobe clock */
4018                 OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4019                 DELAY( BITD );                  /* release clock */
4020         }
4021
4022         *data=byte;
4023         return 0;
4024 }
4025 #undef BITD
4026
4027 /* Write to the MSP or DPL registers */
4028 void msp_dpl_write( bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr,
4029                     unsigned int data){
4030         unsigned int msp_w_addr = i2c_addr;
4031         unsigned char addr_l, addr_h, data_h, data_l ;
4032         addr_h = (addr >>8) & 0xff;
4033         addr_l = addr & 0xff;
4034         data_h = (data >>8) & 0xff;
4035         data_l = data & 0xff;
4036
4037         i2c_start(bktr);
4038         i2c_write_byte(bktr, msp_w_addr);
4039         i2c_write_byte(bktr, dev);
4040         i2c_write_byte(bktr, addr_h);
4041         i2c_write_byte(bktr, addr_l);
4042         i2c_write_byte(bktr, data_h);
4043         i2c_write_byte(bktr, data_l);
4044         i2c_stop(bktr);
4045 }
4046
4047 /* Read from the MSP or DPL registers */
4048 unsigned int msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr){
4049         unsigned int data;
4050         unsigned char addr_l, addr_h, data_1, data_2, dev_r ;
4051         addr_h = (addr >>8) & 0xff;
4052         addr_l = addr & 0xff;
4053         dev_r = dev+1;
4054
4055         i2c_start(bktr);
4056         i2c_write_byte(bktr,i2c_addr);
4057         i2c_write_byte(bktr,dev_r);
4058         i2c_write_byte(bktr,addr_h);
4059         i2c_write_byte(bktr,addr_l);
4060
4061         i2c_start(bktr);
4062         i2c_write_byte(bktr,i2c_addr+1);
4063         i2c_read_byte(bktr,&data_1, 0);
4064         i2c_read_byte(bktr,&data_2, 1);
4065         i2c_stop(bktr);
4066         data = (data_1<<8) | data_2;
4067         return data;
4068 }
4069
4070 /* Reset the MSP or DPL chip */
4071 /* The user can block the reset (which is handy if you initialise the
4072  * MSP audio in another operating system first (eg in Windows)
4073  */
4074 void msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr ) {
4075
4076 #ifndef BKTR_NO_MSP_RESET
4077         /* put into reset mode */
4078         i2c_start(bktr);
4079         i2c_write_byte(bktr, i2c_addr);
4080         i2c_write_byte(bktr, 0x00);
4081         i2c_write_byte(bktr, 0x80);
4082         i2c_write_byte(bktr, 0x00);
4083         i2c_stop(bktr);
4084
4085         /* put back to operational mode */
4086         i2c_start(bktr);
4087         i2c_write_byte(bktr, i2c_addr);
4088         i2c_write_byte(bktr, 0x00);
4089         i2c_write_byte(bktr, 0x00);
4090         i2c_write_byte(bktr, 0x00);
4091         i2c_stop(bktr);
4092 #endif
4093         return;
4094
4095 }
4096
4097 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
4098
4099         /* XXX errors ignored */
4100         i2c_start(bktr);
4101         i2c_write_byte(bktr,bktr->remote_control_addr);
4102         i2c_read_byte(bktr,&(remote->data[0]), 0);
4103         i2c_read_byte(bktr,&(remote->data[1]), 0);
4104         i2c_read_byte(bktr,&(remote->data[2]), 0);
4105         i2c_stop(bktr);
4106
4107         return;
4108 }
4109
4110 #endif /* defined(BKTR_USE_FREEBSD_SMBUS) */
4111
4112
4113 #if defined( I2C_SOFTWARE_PROBE )
4114
4115 /*
4116  * we are keeping this around for any parts that we need to probe
4117  * but that CANNOT be probed via an i2c read.
4118  * this is necessary because the hardware i2c mechanism
4119  * cannot be programmed for 1 byte writes.
4120  * currently there are no known i2c parts that we need to probe
4121  * and that cannot be safely read.
4122  */
4123 static int      i2cProbe( bktr_ptr_t bktr, int addr );
4124 #define BITD            40
4125 #define EXTRA_START
4126
4127 /*
4128  * probe for an I2C device at addr.
4129  */
4130 static int
4131 i2cProbe( bktr_ptr_t bktr, int addr )
4132 {
4133         int             x, status;
4134
4135         /* the START */
4136 #if defined( EXTRA_START )
4137         OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD );        /* release data */
4138         OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD );        /* release clock */
4139 #endif /* EXTRA_START */
4140         OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD );        /* lower data */
4141         OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD );        /* lower clock */
4142
4143         /* write addr */
4144         for ( x = 7; x >= 0; --x ) {
4145                 if ( addr & (1<<x) ) {
4146                         OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4147                         DELAY( BITD );          /* assert HI data */
4148                         OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
4149                         DELAY( BITD );          /* strobe clock */
4150                         OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
4151                         DELAY( BITD );          /* release clock */
4152                 }
4153                 else {
4154                         OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4155                         DELAY( BITD );          /* assert LO data */
4156                         OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
4157                         DELAY( BITD );          /* strobe clock */
4158                         OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
4159                         DELAY( BITD );          /* release clock */
4160                 }
4161         }
4162
4163         /* look for an ACK */
4164         OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD );        /* float data */
4165         OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD );        /* strobe clock */
4166         status = INL(bktr, BKTR_I2C_DATA_CTL) & 1;      /* read the ACK bit */
4167         OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD );        /* release clock */
4168
4169         /* the STOP */
4170         OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD );        /* lower clock & data */
4171         OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD );        /* release clock */
4172         OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD );        /* release data */
4173
4174         return( status );
4175 }
4176 #undef EXTRA_START
4177 #undef BITD
4178
4179 #endif /* I2C_SOFTWARE_PROBE */
4180
4181
4182 #define ABSENT          (-1)