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