sys/dev/video/bktr/bktr_core.c

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