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