sys/dev/video/bktr/bktr_core.c

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