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