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/malloc.h>
 113 #include <sys/mutex.h>
 114 #include <sys/proc.h>
 115 #include <sys/signalvar.h>
 116 #include <sys/selinfo.h>
 117 #include <sys/uio.h>
 118
 119 #include <vm/vm.h>
 120 #include <vm/vm_kern.h>
 121 #include <vm/pmap.h>
 122 #include <vm/vm_extern.h>
 123
 124 #include <sys/bus.h>            /* used by smbus and newbus */
 125
 126 #if (__FreeBSD_version < 500000)
 127 #include <machine/clock.h>              /* for DELAY */
 128 #define PROC_LOCK(p)
 129 #define PROC_UNLOCK(p)
 130 #include <pci/pcivar.h>
 131 #else
 132 #include <dev/pci/pcivar.h>
 133 #endif
 134
 135 #include <machine/bus.h>
 136 #include <sys/bus.h>
 137
 138 #include <dev/bktr/ioctl_meteor.h>
 139 #include <dev/bktr/ioctl_bt848.h>       /* extensions to ioctl_meteor.h */
 140 #include <dev/bktr/bktr_reg.h>
 141 #include <dev/bktr/bktr_tuner.h>
 142 #include <dev/bktr/bktr_card.h>
 143 #include <dev/bktr/bktr_audio.h>
 144 #include <dev/bktr/bktr_os.h>
 145 #include <dev/bktr/bktr_core.h>
 146 #if defined(BKTR_FREEBSD_MODULE)
 147 #include <dev/bktr/bktr_mem.h>
 148 #endif
 149
 150 #if defined(BKTR_USE_FREEBSD_SMBUS)
 151 #include <dev/bktr/bktr_i2c.h>
 152 #include <dev/smbus/smbconf.h>
 153 #include <dev/iicbus/iiconf.h>
 154 #include "smbus_if.h"
 155 #include "iicbus_if.h"
 156 #endif
 157
 158 const char *
 159 bktr_name(bktr_ptr_t bktr)
 160 {
 161   return bktr->bktr_xname;
 162 }
 163
 164
 165 #endif  /* __FreeBSD__ */
 166
 167
 168 /****************/
 169 /* *** BSDI *** */
 170 /****************/
 171 #ifdef __bsdi__
 172 #define PROC_LOCK(p)
 173 #define PROC_UNLOCK(p)
 174 #endif /* __bsdi__ */
 175
 176
 177 /**************************/
 178 /* *** OpenBSD/NetBSD *** */
 179 /**************************/
 180 #if defined(__NetBSD__) || defined(__OpenBSD__)
 181
 182 #include <sys/param.h>
 183 #include <sys/systm.h>
 184 #include <sys/kernel.h>
 185 #include <sys/signalvar.h>
 186 #include <sys/vnode.h>
 187
 188 #ifdef __NetBSD__
 189 #include <uvm/uvm_extern.h>
 190 #else
 191 #include <vm/vm.h>
 192 #include <vm/vm_kern.h>
 193 #include <vm/pmap.h>
 194 #include <vm/vm_extern.h>
 195 #endif
 196
 197 #include <sys/inttypes.h>               /* uintptr_t */
 198 #include <dev/ic/bt8xx.h>
 199 #include <dev/pci/bktr/bktr_reg.h>
 200 #include <dev/pci/bktr/bktr_tuner.h>
 201 #include <dev/pci/bktr/bktr_card.h>
 202 #include <dev/pci/bktr/bktr_audio.h>
 203 #include <dev/pci/bktr/bktr_core.h>
 204 #include <dev/pci/bktr/bktr_os.h>
 205
 206 static int bt848_format = -1;
 207
 208 const char *
 209 bktr_name(bktr_ptr_t bktr)
 210 {
 211         return (bktr->bktr_dev.dv_xname);
 212 }
 213
 214 #define PROC_LOCK(p)
 215 #define PROC_UNLOCK(p)
 216
 217 #endif /* __NetBSD__ || __OpenBSD__ */
 218
 219
 220 typedef u_char bool_t;
 221
 222 #define BKTRPRI (PZERO+8)|PCATCH
 223 #define VBIPRI  (PZERO-4)|PCATCH
 224
 225
 226 /*
 227  * memory allocated for DMA programs
 228  */
 229 #define DMA_PROG_ALLOC          (8 * PAGE_SIZE)
 230
 231 /* When to split a dma transfer , the bt848 has timing as well as
 232    dma transfer size limitations so that we have to split dma
 233    transfers into two dma requests
 234    */
 235 #define DMA_BT848_SPLIT 319*2
 236
 237 /*
 238  * Allocate enough memory for:
 239  *      768x576 RGB 16 or YUV (16 storage bits/pixel) = 884736 = 216 pages
 240  *
 241  * You may override this using the options "BROOKTREE_ALLOC_PAGES=value"
 242  * in your  kernel configuration file.
 243  */
 244
 245 #ifndef BROOKTREE_ALLOC_PAGES
 246 #define BROOKTREE_ALLOC_PAGES   217*4
 247 #endif
 248 #define BROOKTREE_ALLOC         (BROOKTREE_ALLOC_PAGES * PAGE_SIZE)
 249
 250 /* Definitions for VBI capture.
 251  * There are 16 VBI lines in a PAL video field (32 in a frame),
 252  * and we take 2044 samples from each line (placed in a 2048 byte buffer
 253  * for alignment).
 254  * VBI lines are held in a circular buffer before being read by a
 255  * user program from /dev/vbi.
 256  */
 257
 258 #define MAX_VBI_LINES         16   /* Maximum for all vidoe formats */
 259 #define VBI_LINE_SIZE         2048 /* Store up to 2048 bytes per line */
 260 #define VBI_BUFFER_ITEMS      20   /* Number of frames we buffer */
 261 #define VBI_DATA_SIZE         (VBI_LINE_SIZE * MAX_VBI_LINES * 2)
 262 #define VBI_BUFFER_SIZE       (VBI_DATA_SIZE * VBI_BUFFER_ITEMS)
 263
 264
 265 /*  Defines for fields  */
 266 #define ODD_F  0x01
 267 #define EVEN_F 0x02
 268
 269
 270 /*
 271  * Parameters describing size of transmitted image.
 272  */
 273
 274 static struct format_params format_params[] = {
 275 /* # define BT848_IFORM_F_AUTO             (0x0) - don't matter. */
 276   { 525, 26, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_AUTO,
 277     12,  1600 },
 278 /* # define BT848_IFORM_F_NTSCM            (0x1) */
 279   { 525, 26, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
 280     12, 1600 },
 281 /* # define BT848_IFORM_F_NTSCJ            (0x2) */
 282   { 525, 22, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
 283     12, 1600 },
 284 /* # define BT848_IFORM_F_PALBDGHI         (0x3) */
 285   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1,
 286     16,  2044 },
 287 /* # define BT848_IFORM_F_PALM             (0x4) */
 288   { 525, 22, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
 289     12, 1600 },
 290 /* # define BT848_IFORM_F_PALN             (0x5) */
 291   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1,
 292     16, 2044 },
 293 /* # define BT848_IFORM_F_SECAM            (0x6) */
 294   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0xa0, BT848_IFORM_X_XT1,
 295     16, 2044 },
 296 /* # define BT848_IFORM_F_RSVD             (0x7) - ???? */
 297   { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT0,
 298     16, 2044 },
 299 };
 300
 301 /*
 302  * Table of supported Pixel Formats
 303  */
 304
 305 static struct meteor_pixfmt_internal {
 306         struct meteor_pixfmt public;
 307         u_int                color_fmt;
 308 } pixfmt_table[] = {
 309
 310 { { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,  0x03e0,  0x001f }, 0,0 }, 0x33 },
 311 { { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,  0x03e0,  0x001f }, 1,0 }, 0x33 },
 312
 313 { { 0, METEOR_PIXTYPE_RGB, 2, {   0xf800,  0x07e0,  0x001f }, 0,0 }, 0x22 },
 314 { { 0, METEOR_PIXTYPE_RGB, 2, {   0xf800,  0x07e0,  0x001f }, 1,0 }, 0x22 },
 315
 316 { { 0, METEOR_PIXTYPE_RGB, 3, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x11 },
 317
 318 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,0 }, 0x00 },
 319 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x00 },
 320 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x00 },
 321 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x00 },
 322 { { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 },
 323 { { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x44 },
 324 { { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 },
 325
 326 };
 327 #define PIXFMT_TABLE_SIZE nitems(pixfmt_table)
 328
 329 /*
 330  * Table of Meteor-supported Pixel Formats (for SETGEO compatibility)
 331  */
 332
 333 /*  FIXME:  Also add YUV_422 and YUV_PACKED as well  */
 334 static struct {
 335         u_long               meteor_format;
 336         struct meteor_pixfmt public;
 337 } meteor_pixfmt_table[] = {
 338     { METEOR_GEO_YUV_12,
 339       { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }
 340     },
 341
 342       /* FIXME: Should byte swap flag be on for this one; negative in drvr? */
 343     { METEOR_GEO_YUV_422,
 344       { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }
 345     },
 346     { METEOR_GEO_YUV_PACKED,
 347       { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }
 348     },
 349     { METEOR_GEO_RGB16,
 350       { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,   0x03e0,   0x001f }, 0, 0 }
 351     },
 352     { METEOR_GEO_RGB24,
 353       { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000, 0x00ff00, 0x0000ff }, 0, 0 }
 354     },
 355
 356 };
 357 #define METEOR_PIXFMT_TABLE_SIZE nitems(meteor_pixfmt_table)
 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), (int)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 kernel 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                         kern_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 Dependent 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                                         contigfree(
1805                                           (void *)(uintptr_t)bktr->bigbuf,
1806                                           (bktr->alloc_pages * PAGE_SIZE),
1807                                           M_DEVBUF);
1808 #endif
1809
1810                                         bktr->bigbuf = buf;
1811                                         bktr->alloc_pages = temp;
1812                                         if (bootverbose)
1813                                                 printf("%s: ioctl: Allocating %d bytes\n",
1814                                                         bktr_name(bktr), (int)(temp*PAGE_SIZE));
1815                                 }
1816                                 else
1817                                         error = ENOMEM;
1818                         }
1819                 }
1820
1821                 if (error)
1822                         return error;
1823
1824                 bktr->rows = geo->rows;
1825                 bktr->cols = geo->columns;
1826                 bktr->frames = geo->frames;
1827
1828                 /*  Pixel format (if in meteor pixfmt compatibility mode)  */
1829                 if ( bktr->pixfmt_compat ) {
1830                         bktr->format = METEOR_GEO_YUV_422;
1831                         switch (geo->oformat & METEOR_GEO_OUTPUT_MASK) {
1832                         case 0:                 /* default */
1833                         case METEOR_GEO_RGB16:
1834                                     bktr->format = METEOR_GEO_RGB16;
1835                                     break;
1836                         case METEOR_GEO_RGB24:
1837                                     bktr->format = METEOR_GEO_RGB24;
1838                                     break;
1839                         case METEOR_GEO_YUV_422:
1840                                     bktr->format = METEOR_GEO_YUV_422;
1841                                     if (geo->oformat & METEOR_GEO_YUV_12)
1842                                         bktr->format = METEOR_GEO_YUV_12;
1843                                     break;
1844                         case METEOR_GEO_YUV_PACKED:
1845                                     bktr->format = METEOR_GEO_YUV_PACKED;
1846                                     break;
1847                         }
1848                         bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
1849                 }
1850
1851                 if (bktr->flags & METEOR_CAP_MASK) {
1852
1853                         if (bktr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
1854                                 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
1855                                 case METEOR_ONLY_ODD_FIELDS:
1856                                         bktr->flags |= METEOR_WANT_ODD;
1857                                         break;
1858                                 case METEOR_ONLY_EVEN_FIELDS:
1859                                         bktr->flags |= METEOR_WANT_EVEN;
1860                                         break;
1861                                 default:
1862                                         bktr->flags |= METEOR_WANT_MASK;
1863                                         break;
1864                                 }
1865
1866                                 start_capture(bktr, METEOR_CONTIN);
1867                                 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
1868                                 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
1869                                 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
1870                                 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
1871                                                     BT848_INT_VSYNC      |
1872                                                     BT848_INT_FMTCHG);
1873                         }
1874                 }
1875                 break;
1876         /* end of METEORSETGEO */
1877
1878         /* FIXME. The Capture Area currently has the following restrictions:
1879         GENERAL
1880          y_offset may need to be even in interlaced modes
1881         RGB24 - Interlaced mode
1882          x_size must be greater than or equal to 1.666*METEORSETGEO width (cols)
1883          y_size must be greater than or equal to METEORSETGEO height (rows)
1884         RGB24 - Even Only (or Odd Only) mode
1885          x_size must be greater than or equal to 1.666*METEORSETGEO width (cols)
1886          y_size must be greater than or equal to 2*METEORSETGEO height (rows)
1887         YUV12 - Interlaced mode
1888          x_size must be greater than or equal to METEORSETGEO width (cols)
1889          y_size must be greater than or equal to METEORSETGEO height (rows)
1890         YUV12 - Even Only (or Odd Only) mode
1891          x_size must be greater than or equal to METEORSETGEO width (cols)
1892          y_size must be greater than or equal to 2*METEORSETGEO height (rows)
1893         */
1894
1895         case BT848_SCAPAREA: /* set capture area of each video frame */
1896                 /* can't change parameters while capturing */
1897                 if (bktr->flags & METEOR_CAP_MASK)
1898                         return( EBUSY );
1899
1900                 cap_area = (struct bktr_capture_area *) arg;
1901                 bktr->capture_area_x_offset = cap_area->x_offset;
1902                 bktr->capture_area_y_offset = cap_area->y_offset;
1903                 bktr->capture_area_x_size   = cap_area->x_size;
1904                 bktr->capture_area_y_size   = cap_area->y_size;
1905                 bktr->capture_area_enabled  = TRUE;
1906
1907                 bktr->dma_prog_loaded = FALSE;
1908                 break;
1909
1910         case BT848_GCAPAREA: /* get capture area of each video frame */
1911                 cap_area = (struct bktr_capture_area *) arg;
1912                 if (bktr->capture_area_enabled == FALSE) {
1913                         cap_area->x_offset = 0;
1914                         cap_area->y_offset = 0;
1915                         cap_area->x_size   = format_params[
1916                                 bktr->format_params].scaled_hactive;
1917                         cap_area->y_size   = format_params[
1918                                 bktr->format_params].vactive;
1919                 } else {
1920                         cap_area->x_offset = bktr->capture_area_x_offset;
1921                         cap_area->y_offset = bktr->capture_area_y_offset;
1922                         cap_area->x_size   = bktr->capture_area_x_size;
1923                         cap_area->y_size   = bktr->capture_area_y_size;
1924                 }
1925                 break;
1926
1927         default:
1928                 return common_ioctl( bktr, cmd, arg );
1929         }
1930
1931         return( 0 );
1932 }
1933
1934 /*
1935  * tuner ioctls
1936  */
1937 int
1938 tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td )
1939 {
1940         int             tmp_int;
1941         int             temp, temp1;
1942         int             offset;
1943         int             count;
1944         u_char          *buf;
1945         u_long          par;
1946         u_char          write;
1947         int             i2c_addr;
1948         int             i2c_port;
1949         u_long          data;
1950
1951         switch ( cmd ) {
1952
1953         case REMOTE_GETKEY:
1954                 /* Read the last key pressed by the Remote Control */
1955                 if (bktr->remote_control == 0) return (EINVAL);
1956                 remote_read(bktr, (struct bktr_remote *)arg);
1957                 break;
1958
1959 #if defined( TUNER_AFC )
1960         case TVTUNER_SETAFC:
1961                 bktr->tuner.afc = (*(int *)arg != 0);
1962                 break;
1963
1964         case TVTUNER_GETAFC:
1965                 *(int *)arg = bktr->tuner.afc;
1966                 /* XXX Perhaps use another bit to indicate AFC success? */
1967                 break;
1968 #endif /* TUNER_AFC */
1969
1970         case TVTUNER_SETCHNL:
1971                 temp_mute( bktr, TRUE );
1972                 temp = tv_channel( bktr, (int)*(unsigned long *)arg );
1973                 if ( temp < 0 ) {
1974                         temp_mute( bktr, FALSE );
1975                         return( EINVAL );
1976                 }
1977                 *(unsigned long *)arg = temp;
1978
1979                 /* after every channel change, we must restart the MSP34xx */
1980                 /* audio chip to reselect NICAM STEREO or MONO audio */
1981                 if ( bktr->card.msp3400c )
1982                   msp_autodetect( bktr );
1983
1984                 /* after every channel change, we must restart the DPL35xx */
1985                 if ( bktr->card.dpl3518a )
1986                   dpl_autodetect( bktr );
1987
1988                 temp_mute( bktr, FALSE );
1989                 break;
1990
1991         case TVTUNER_GETCHNL:
1992                 *(unsigned long *)arg = bktr->tuner.channel;
1993                 break;
1994
1995         case TVTUNER_SETTYPE:
1996                 temp = *(unsigned long *)arg;
1997                 if ( (temp < CHNLSET_MIN) || (temp > CHNLSET_MAX) )
1998                         return( EINVAL );
1999                 bktr->tuner.chnlset = temp;
2000                 break;
2001
2002         case TVTUNER_GETTYPE:
2003                 *(unsigned long *)arg = bktr->tuner.chnlset;
2004                 break;
2005
2006         case TVTUNER_GETSTATUS:
2007                 temp = get_tuner_status( bktr );
2008                 *(unsigned long *)arg = temp & 0xff;
2009                 break;
2010
2011         case TVTUNER_SETFREQ:
2012                 temp_mute( bktr, TRUE );
2013                 temp = tv_freq( bktr, (int)*(unsigned long *)arg, TV_FREQUENCY);
2014                 temp_mute( bktr, FALSE );
2015                 if ( temp < 0 ) {
2016                         temp_mute( bktr, FALSE );
2017                         return( EINVAL );
2018                 }
2019                 *(unsigned long *)arg = temp;
2020
2021                 /* after every channel change, we must restart the MSP34xx */
2022                 /* audio chip to reselect NICAM STEREO or MONO audio */
2023                 if ( bktr->card.msp3400c )
2024                   msp_autodetect( bktr );
2025
2026                 /* after every channel change, we must restart the DPL35xx */
2027                 if ( bktr->card.dpl3518a )
2028                   dpl_autodetect( bktr );
2029
2030                 temp_mute( bktr, FALSE );
2031                 break;
2032
2033         case TVTUNER_GETFREQ:
2034                 *(unsigned long *)arg = bktr->tuner.frequency;
2035                 break;
2036
2037         case TVTUNER_GETCHNLSET:
2038                 return tuner_getchnlset((struct bktr_chnlset *)arg);
2039
2040         case BT848_SAUDIO:      /* set audio channel */
2041                 if ( set_audio( bktr, *(int*)arg ) < 0 )
2042                         return( EIO );
2043                 break;
2044
2045         /* hue is a 2's compliment number, -90' to +89.3' in 0.7' steps */
2046         case BT848_SHUE:        /* set hue */
2047                 OUTB(bktr, BKTR_HUE, (u_char)(*(int*)arg & 0xff));
2048                 break;
2049
2050         case BT848_GHUE:        /* get hue */
2051                 *(int*)arg = (signed char)(INB(bktr, BKTR_HUE) & 0xff);
2052                 break;
2053
2054         /* brightness is a 2's compliment #, -50 to +%49.6% in 0.39% steps */
2055         case BT848_SBRIG:       /* set brightness */
2056                 OUTB(bktr, BKTR_BRIGHT, (u_char)(*(int *)arg & 0xff));
2057                 break;
2058
2059         case BT848_GBRIG:       /* get brightness */
2060                 *(int *)arg = (signed char)(INB(bktr, BKTR_BRIGHT) & 0xff);
2061                 break;
2062
2063         /*  */
2064         case BT848_SCSAT:       /* set chroma saturation */
2065                 tmp_int = *(int*)arg;
2066
2067                 temp = INB(bktr, BKTR_E_CONTROL);
2068                 temp1 = INB(bktr, BKTR_O_CONTROL);
2069                 if ( tmp_int & BIT_EIGHT_HIGH ) {
2070                         temp |= (BT848_E_CONTROL_SAT_U_MSB |
2071                                  BT848_E_CONTROL_SAT_V_MSB);
2072                         temp1 |= (BT848_O_CONTROL_SAT_U_MSB |
2073                                   BT848_O_CONTROL_SAT_V_MSB);
2074                 }
2075                 else {
2076                         temp &= ~(BT848_E_CONTROL_SAT_U_MSB |
2077                                   BT848_E_CONTROL_SAT_V_MSB);
2078                         temp1 &= ~(BT848_O_CONTROL_SAT_U_MSB |
2079                                    BT848_O_CONTROL_SAT_V_MSB);
2080                 }
2081
2082                 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2083                 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
2084                 OUTB(bktr, BKTR_E_CONTROL, temp);
2085                 OUTB(bktr, BKTR_O_CONTROL, temp1);
2086                 break;
2087
2088         case BT848_GCSAT:       /* get chroma saturation */
2089                 tmp_int = (int)(INB(bktr, BKTR_SAT_V_LO) & 0xff);
2090                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
2091                         tmp_int |= BIT_EIGHT_HIGH;
2092                 *(int*)arg = tmp_int;
2093                 break;
2094
2095         /*  */
2096         case BT848_SVSAT:       /* set chroma V saturation */
2097                 tmp_int = *(int*)arg;
2098
2099                 temp = INB(bktr, BKTR_E_CONTROL);
2100                 temp1 = INB(bktr, BKTR_O_CONTROL);
2101                 if ( tmp_int & BIT_EIGHT_HIGH) {
2102                         temp |= BT848_E_CONTROL_SAT_V_MSB;
2103                         temp1 |= BT848_O_CONTROL_SAT_V_MSB;
2104                 }
2105                 else {
2106                         temp &= ~BT848_E_CONTROL_SAT_V_MSB;
2107                         temp1 &= ~BT848_O_CONTROL_SAT_V_MSB;
2108                 }
2109
2110                 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
2111                 OUTB(bktr, BKTR_E_CONTROL, temp);
2112                 OUTB(bktr, BKTR_O_CONTROL, temp1);
2113                 break;
2114
2115         case BT848_GVSAT:       /* get chroma V saturation */
2116                 tmp_int = (int)INB(bktr, BKTR_SAT_V_LO) & 0xff;
2117                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
2118                         tmp_int |= BIT_EIGHT_HIGH;
2119                 *(int*)arg = tmp_int;
2120                 break;
2121
2122         /*  */
2123         case BT848_SUSAT:       /* set chroma U saturation */
2124                 tmp_int = *(int*)arg;
2125
2126                 temp = INB(bktr, BKTR_E_CONTROL);
2127                 temp1 = INB(bktr, BKTR_O_CONTROL);
2128                 if ( tmp_int & BIT_EIGHT_HIGH ) {
2129                         temp |= BT848_E_CONTROL_SAT_U_MSB;
2130                         temp1 |= BT848_O_CONTROL_SAT_U_MSB;
2131                 }
2132                 else {
2133                         temp &= ~BT848_E_CONTROL_SAT_U_MSB;
2134                         temp1 &= ~BT848_O_CONTROL_SAT_U_MSB;
2135                 }
2136
2137                 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
2138                 OUTB(bktr, BKTR_E_CONTROL, temp);
2139                 OUTB(bktr, BKTR_O_CONTROL, temp1);
2140                 break;
2141
2142         case BT848_GUSAT:       /* get chroma U saturation */
2143                 tmp_int = (int)INB(bktr, BKTR_SAT_U_LO) & 0xff;
2144                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_U_MSB )
2145                         tmp_int |= BIT_EIGHT_HIGH;
2146                 *(int*)arg = tmp_int;
2147                 break;
2148
2149 /* lr 970528 luma notch etc - 3 high bits of e_control/o_control */
2150
2151         case BT848_SLNOTCH:     /* set luma notch */
2152                 tmp_int = (*(int *)arg & 0x7) << 5 ;
2153                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~0xe0);
2154                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~0xe0);
2155                 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | tmp_int);
2156                 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | tmp_int);
2157                 break;
2158
2159         case BT848_GLNOTCH:     /* get luma notch */
2160                 *(int *)arg = (int) ( (INB(bktr, BKTR_E_CONTROL) & 0xe0) >> 5) ;
2161                 break;
2162
2163
2164         /*  */
2165         case BT848_SCONT:       /* set contrast */
2166                 tmp_int = *(int*)arg;
2167
2168                 temp = INB(bktr, BKTR_E_CONTROL);
2169                 temp1 = INB(bktr, BKTR_O_CONTROL);
2170                 if ( tmp_int & BIT_EIGHT_HIGH ) {
2171                         temp |= BT848_E_CONTROL_CON_MSB;
2172                         temp1 |= BT848_O_CONTROL_CON_MSB;
2173                 }
2174                 else {
2175                         temp &= ~BT848_E_CONTROL_CON_MSB;
2176                         temp1 &= ~BT848_O_CONTROL_CON_MSB;
2177                 }
2178
2179                 OUTB(bktr, BKTR_CONTRAST_LO, (u_char)(tmp_int & 0xff));
2180                 OUTB(bktr, BKTR_E_CONTROL, temp);
2181                 OUTB(bktr, BKTR_O_CONTROL, temp1);
2182                 break;
2183
2184         case BT848_GCONT:       /* get contrast */
2185                 tmp_int = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
2186                 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_CON_MSB )
2187                         tmp_int |= BIT_EIGHT_HIGH;
2188                 *(int*)arg = tmp_int;
2189                 break;
2190
2191                 /*  FIXME:  SCBARS and CCBARS require a valid int *        */
2192                 /*    argument to succeed, but its not used; consider      */
2193                 /*    using the arg to store the on/off state so           */
2194                 /*    there's only one ioctl() needed to turn cbars on/off */
2195         case BT848_SCBARS:      /* set colorbar output */
2196                 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_COLOR_BARS);
2197                 break;
2198
2199         case BT848_CCBARS:      /* clear colorbar output */
2200                 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) & ~(BT848_COLOR_CTL_COLOR_BARS));
2201                 break;
2202
2203         case BT848_GAUDIO:      /* get audio channel */
2204                 temp = bktr->audio_mux_select;
2205                 if ( bktr->audio_mute_state == TRUE )
2206                         temp |= AUDIO_MUTE;
2207                 *(int*)arg = temp;
2208                 break;
2209
2210         case BT848_SBTSC:       /* set audio channel */
2211                 if ( set_BTSC( bktr, *(int*)arg ) < 0 )
2212                         return( EIO );
2213                 break;
2214
2215         case BT848_WEEPROM:     /* write eeprom */
2216                 offset = (((struct eeProm *)arg)->offset);
2217                 count = (((struct eeProm *)arg)->count);
2218                 buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
2219                 if ( writeEEProm( bktr, offset, count, buf ) < 0 )
2220                         return( EIO );
2221                 break;
2222
2223         case BT848_REEPROM:     /* read eeprom */
2224                 offset = (((struct eeProm *)arg)->offset);
2225                 count = (((struct eeProm *)arg)->count);
2226                 buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
2227                 if ( readEEProm( bktr, offset, count, buf ) < 0 )
2228                         return( EIO );
2229                 break;
2230
2231         case BT848_SIGNATURE:
2232                 offset = (((struct eeProm *)arg)->offset);
2233                 count = (((struct eeProm *)arg)->count);
2234                 buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
2235                 if ( signCard( bktr, offset, count, buf ) < 0 )
2236                         return( EIO );
2237                 break;
2238
2239         /* Ioctl's for direct gpio access */
2240 #ifdef BKTR_GPIO_ACCESS
2241         case BT848_GPIO_GET_EN:
2242                 *(int*)arg = INL(bktr, BKTR_GPIO_OUT_EN);
2243                 break;
2244
2245         case BT848_GPIO_SET_EN:
2246                 OUTL(bktr, BKTR_GPIO_OUT_EN, *(int*)arg);
2247                 break;
2248
2249         case BT848_GPIO_GET_DATA:
2250                 *(int*)arg = INL(bktr, BKTR_GPIO_DATA);
2251                 break;
2252
2253         case BT848_GPIO_SET_DATA:
2254                 OUTL(bktr, BKTR_GPIO_DATA, *(int*)arg);
2255                 break;
2256 #endif /* BKTR_GPIO_ACCESS */
2257
2258         /* Ioctl's for running the tuner device in radio mode           */
2259
2260         case RADIO_GETMODE:
2261             *(unsigned char *)arg = bktr->tuner.radio_mode;
2262             break;
2263
2264         case RADIO_SETMODE:
2265             bktr->tuner.radio_mode = *(unsigned char *)arg;
2266             break;
2267
2268         case RADIO_GETFREQ:
2269             *(unsigned long *)arg = bktr->tuner.frequency;
2270             break;
2271
2272         case RADIO_SETFREQ:
2273             /* The argument to this ioctl is NOT freq*16. It is
2274             ** freq*100.
2275             */
2276
2277             temp=(int)*(unsigned long *)arg;
2278
2279 #ifdef BKTR_RADIO_DEBUG
2280             printf("%s: arg=%d temp=%d\n", bktr_name(bktr),
2281                    (int)*(unsigned long *)arg, temp);
2282 #endif
2283
2284 #ifndef BKTR_RADIO_NOFREQCHECK
2285             /* According to the spec. sheet the band: 87.5MHz-108MHz    */
2286             /* is supported.                                            */
2287             if(temp<8750 || temp>10800) {
2288               printf("%s: Radio frequency out of range\n", bktr_name(bktr));
2289               return(EINVAL);
2290               }
2291 #endif
2292             temp_mute( bktr, TRUE );
2293             temp = tv_freq( bktr, temp, FM_RADIO_FREQUENCY );
2294             temp_mute( bktr, FALSE );
2295 #ifdef BKTR_RADIO_DEBUG
2296   if(temp)
2297     printf("%s: tv_freq returned: %d\n", bktr_name(bktr), temp);
2298 #endif
2299             if ( temp < 0 )
2300                     return( EINVAL );
2301             *(unsigned long *)arg = temp;
2302             break;
2303
2304         /* Luigi's I2CWR ioctl */
2305         case BT848_I2CWR:
2306                 par = *(u_long *)arg;
2307                 write = (par >> 24) & 0xff ;
2308                 i2c_addr = (par >> 16) & 0xff ;
2309                 i2c_port = (par >> 8) & 0xff ;
2310                 data = (par) & 0xff ;
2311
2312                 if (write) {
2313                         i2cWrite( bktr, i2c_addr, i2c_port, data);
2314                 } else {
2315                         data = i2cRead( bktr, i2c_addr);
2316                 }
2317                 *(u_long *)arg = (par & 0xffffff00) | ( data & 0xff );
2318                 break;
2319
2320
2321 #ifdef BT848_MSP_READ
2322         /* I2C ioctls to allow userland access to the MSP chip */
2323         case BT848_MSP_READ:
2324                 {
2325                 struct bktr_msp_control *msp;
2326                 msp = (struct bktr_msp_control *) arg;
2327                 msp->data = msp_dpl_read(bktr, bktr->msp_addr,
2328                                          msp->function, msp->address);
2329                 break;
2330                 }
2331
2332         case BT848_MSP_WRITE:
2333                 {
2334                 struct bktr_msp_control *msp;
2335                 msp = (struct bktr_msp_control *) arg;
2336                 msp_dpl_write(bktr, bktr->msp_addr, msp->function,
2337                              msp->address, msp->data );
2338                 break;
2339                 }
2340
2341         case BT848_MSP_RESET:
2342                 msp_dpl_reset(bktr, bktr->msp_addr);
2343                 break;
2344 #endif
2345
2346         default:
2347                 return common_ioctl( bktr, cmd, arg );
2348         }
2349
2350         return( 0 );
2351 }
2352
2353
2354 /*
2355  * common ioctls
2356  */
2357 static int
2358 common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg )
2359 {
2360         int                           pixfmt;
2361         unsigned int                  temp;
2362         struct meteor_pixfmt          *pf_pub;
2363
2364         switch (cmd) {
2365
2366         case METEORSINPUT:      /* set input device */
2367                 /*Bt848 has 3 MUX Inputs. Bt848A/849A/878/879 has 4 MUX Inputs*/
2368                 /* On the original bt848 boards, */
2369                 /*   Tuner is MUX0, RCA is MUX1, S-Video is MUX2 */
2370                 /* On the Hauppauge bt878 boards, */
2371                 /*   Tuner is MUX0, RCA is MUX3 */
2372                 /* Unfortunately Meteor driver codes DEV_RCA as DEV_0, so we */
2373                 /* stick with this system in our Meteor Emulation */
2374
2375                 switch(*(unsigned long *)arg & METEOR_DEV_MASK) {
2376
2377                 /* this is the RCA video input */
2378                 case 0:         /* default */
2379                 case METEOR_INPUT_DEV0:
2380                   /* METEOR_INPUT_DEV_RCA: */
2381                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2382                           | METEOR_DEV0;
2383                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM)
2384                                          & ~BT848_IFORM_MUXSEL);
2385
2386                         /* work around for new Hauppauge 878 cards */
2387                         if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2388                                 (bktr->id==BROOKTREE_878 ||
2389                                  bktr->id==BROOKTREE_879) )
2390                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2391                         else
2392                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2393
2394                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2395                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2396                         set_audio( bktr, AUDIO_EXTERN );
2397                         break;
2398
2399                 /* this is the tuner input */
2400                 case METEOR_INPUT_DEV1:
2401                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2402                                 | METEOR_DEV1;
2403                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2404                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX0);
2405                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2406                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2407                         set_audio( bktr, AUDIO_TUNER );
2408                         break;
2409
2410                 /* this is the S-VHS input, but with a composite camera */
2411                 case METEOR_INPUT_DEV2:
2412                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2413                                 | METEOR_DEV2;
2414                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2415                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2416                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2417                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_O_CONTROL_COMP);
2418                         set_audio( bktr, AUDIO_EXTERN );
2419                         break;
2420
2421                 /* this is the S-VHS input */
2422                 case METEOR_INPUT_DEV_SVIDEO:
2423                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2424                                 | METEOR_DEV_SVIDEO;
2425                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2426                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
2427                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_COMP);
2428                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_COMP);
2429                         set_audio( bktr, AUDIO_EXTERN );
2430                         break;
2431
2432                 case METEOR_INPUT_DEV3:
2433                   if ((bktr->id == BROOKTREE_848A) ||
2434                       (bktr->id == BROOKTREE_849A) ||
2435                       (bktr->id == BROOKTREE_878) ||
2436                       (bktr->id == BROOKTREE_879) ) {
2437                         bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
2438                                 | METEOR_DEV3;
2439                         OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
2440
2441                         /* work around for new Hauppauge 878 cards */
2442                         if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
2443                                 (bktr->id==BROOKTREE_878 ||
2444                                  bktr->id==BROOKTREE_879) )
2445                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
2446                         else
2447                                 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
2448
2449                         OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
2450                         OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
2451                         set_audio( bktr, AUDIO_EXTERN );
2452
2453                         break;
2454                   }
2455
2456                 default:
2457                         return( EINVAL );
2458                 }
2459                 break;
2460
2461         case METEORGINPUT:      /* get input device */
2462                 *(u_long *)arg = bktr->flags & METEOR_DEV_MASK;
2463                 break;
2464
2465         case METEORSACTPIXFMT:
2466                 if (( *(int *)arg < 0 ) ||
2467                     ( *(int *)arg >= PIXFMT_TABLE_SIZE ))
2468                         return( EINVAL );
2469
2470                 bktr->pixfmt          = *(int *)arg;
2471                 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
2472                      | pixfmt_swap_flags( bktr->pixfmt ));
2473                 bktr->pixfmt_compat   = FALSE;
2474                 break;
2475
2476         case METEORGACTPIXFMT:
2477                 *(int *)arg = bktr->pixfmt;
2478                 break;
2479
2480         case METEORGSUPPIXFMT :
2481                 pf_pub = (struct meteor_pixfmt *)arg;
2482                 pixfmt = pf_pub->index;
2483
2484                 if (( pixfmt < 0 ) || ( pixfmt >= PIXFMT_TABLE_SIZE ))
2485                         return( EINVAL );
2486
2487                 memcpy( pf_pub, &pixfmt_table[ pixfmt ].public,
2488                         sizeof( *pf_pub ) );
2489
2490                 /*  Patch in our format index  */
2491                 pf_pub->index       = pixfmt;
2492                 break;
2493
2494 #if defined( STATUS_SUM )
2495         case BT848_GSTATUS:     /* reap status */
2496                 {
2497                 DECLARE_INTR_MASK(s);
2498                 DISABLE_INTR(s);
2499                 temp = status_sum;
2500                 status_sum = 0;
2501                 ENABLE_INTR(s);
2502                 *(u_int*)arg = temp;
2503                 break;
2504                 }
2505 #endif /* STATUS_SUM */
2506
2507         default:
2508                 return( ENOTTY );
2509         }
2510
2511         return( 0 );
2512 }
2513
2514
2515
2516
2517 /******************************************************************************
2518  * bt848 RISC programming routines:
2519  */
2520
2521
2522 /*
2523  *
2524  */
2525 #ifdef BT848_DEBUG
2526 static int
2527 dump_bt848( bktr_ptr_t bktr )
2528 {
2529         int     r[60]={
2530                            4,    8, 0xc, 0x8c, 0x10, 0x90, 0x14, 0x94,
2531                         0x18, 0x98, 0x1c, 0x9c, 0x20, 0xa0, 0x24, 0xa4,
2532                         0x28, 0x2c, 0xac, 0x30, 0x34, 0x38, 0x3c, 0x40,
2533                         0xc0, 0x48, 0x4c, 0xcc, 0x50, 0xd0, 0xd4, 0x60,
2534                         0x64, 0x68, 0x6c, 0xec, 0xd8, 0xdc, 0xe0, 0xe4,
2535                         0,       0,    0,    0
2536                    };
2537         int     i;
2538
2539         for (i = 0; i < 40; i+=4) {
2540                 printf("%s: Reg:value : \t%x:%x \t%x:%x \t %x:%x \t %x:%x\n",
2541                        bktr_name(bktr),
2542                        r[i], INL(bktr, r[i]),
2543                        r[i+1], INL(bktr, r[i+1]),
2544                        r[i+2], INL(bktr, r[i+2]),
2545                        r[i+3], INL(bktr, r[i+3]]));
2546         }
2547
2548         printf("%s: INT STAT %x \n", bktr_name(bktr),
2549                INL(bktr, BKTR_INT_STAT));
2550         printf("%s: Reg INT_MASK %x \n", bktr_name(bktr),
2551                INL(bktr, BKTR_INT_MASK));
2552         printf("%s: Reg GPIO_DMA_CTL %x \n", bktr_name(bktr),
2553                INW(bktr, BKTR_GPIO_DMA_CTL));
2554
2555         return( 0 );
2556 }
2557
2558 #endif
2559
2560 /*
2561  * build write instruction
2562  */
2563 #define BKTR_FM1      0x6       /* packed data to follow */
2564 #define BKTR_FM3      0xe       /* planar data to follow */
2565 #define BKTR_VRE      0x4       /* Marks the end of the even field */
2566 #define BKTR_VRO      0xC       /* Marks the end of the odd field */
2567 #define BKTR_PXV      0x0       /* valid word (never used) */
2568 #define BKTR_EOL      0x1       /* last dword, 4 bytes */
2569 #define BKTR_SOL      0x2       /* first dword */
2570
2571 #define OP_WRITE      (0x1 << 28)
2572 #define OP_SKIP       (0x2 << 28)
2573 #define OP_WRITEC     (0x5 << 28)
2574 #define OP_JUMP       (0x7 << 28)
2575 #define OP_SYNC       (0x8 << 28)
2576 #define OP_WRITE123   (0x9 << 28)
2577 #define OP_WRITES123  (0xb << 28)
2578 #define OP_SOL        (1 << 27)         /* first instr for scanline */
2579 #define OP_EOL        (1 << 26)
2580
2581 #define BKTR_RESYNC   (1 << 15)
2582 #define BKTR_GEN_IRQ  (1 << 24)
2583
2584 /*
2585  * The RISC status bits can be set/cleared in the RISC programs
2586  * and tested in the Interrupt Handler
2587  */
2588 #define BKTR_SET_RISC_STATUS_BIT0 (1 << 16)
2589 #define BKTR_SET_RISC_STATUS_BIT1 (1 << 17)
2590 #define BKTR_SET_RISC_STATUS_BIT2 (1 << 18)
2591 #define BKTR_SET_RISC_STATUS_BIT3 (1 << 19)
2592
2593 #define BKTR_CLEAR_RISC_STATUS_BIT0 (1 << 20)
2594 #define BKTR_CLEAR_RISC_STATUS_BIT1 (1 << 21)
2595 #define BKTR_CLEAR_RISC_STATUS_BIT2 (1 << 22)
2596 #define BKTR_CLEAR_RISC_STATUS_BIT3 (1 << 23)
2597
2598 #define BKTR_TEST_RISC_STATUS_BIT0 (1 << 28)
2599 #define BKTR_TEST_RISC_STATUS_BIT1 (1 << 29)
2600 #define BKTR_TEST_RISC_STATUS_BIT2 (1 << 30)
2601 #define BKTR_TEST_RISC_STATUS_BIT3 (1U << 31)
2602
2603 static bool_t notclipped (bktr_reg_t * bktr, int x, int width) {
2604     int i;
2605     bktr_clip_t * clip_node;
2606     bktr->clip_start = -1;
2607     bktr->last_y = 0;
2608     bktr->y = 0;
2609     bktr->y2 = width;
2610     bktr->line_length = width;
2611     bktr->yclip = -1;
2612     bktr->yclip2 = -1;
2613     bktr->current_col = 0;
2614
2615     if (bktr->max_clip_node == 0 ) return TRUE;
2616     clip_node = (bktr_clip_t *) &bktr->clip_list[0];
2617
2618
2619     for (i = 0; i < bktr->max_clip_node; i++ ) {
2620         clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2621         if (x >= clip_node->x_min && x <= clip_node->x_max  ) {
2622             bktr->clip_start = i;
2623             return FALSE;
2624         }
2625     }
2626
2627     return TRUE;
2628 }
2629
2630 static bool_t getline(bktr_reg_t *bktr, int x ) {
2631     int i, j;
2632     bktr_clip_t * clip_node ;
2633
2634     if (bktr->line_length == 0 ||
2635         bktr->current_col >= bktr->line_length) return FALSE;
2636
2637     bktr->y = min(bktr->last_y, bktr->line_length);
2638     bktr->y2 = bktr->line_length;
2639
2640     bktr->yclip = bktr->yclip2 = -1;
2641     for (i = bktr->clip_start; i < bktr->max_clip_node; i++ ) {
2642         clip_node = (bktr_clip_t *) &bktr->clip_list[i];
2643         if (x >= clip_node->x_min && x <= clip_node->x_max) {
2644             if (bktr->last_y <= clip_node->y_min) {
2645                 bktr->y =      min(bktr->last_y, bktr->line_length);
2646                 bktr->y2 =     min(clip_node->y_min, bktr->line_length);
2647                 bktr->yclip =  min(clip_node->y_min, bktr->line_length);
2648                 bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
2649                 bktr->last_y = bktr->yclip2;
2650                 bktr->clip_start = i;
2651
2652                 for (j = i+1; j  < bktr->max_clip_node; j++ ) {
2653                     clip_node = (bktr_clip_t *) &bktr->clip_list[j];
2654                     if (x >= clip_node->x_min && x <= clip_node->x_max) {
2655                         if (bktr->last_y >= clip_node->y_min) {
2656                             bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
2657                             bktr->last_y = bktr->yclip2;
2658                             bktr->clip_start = j;
2659                         }
2660                     } else break  ;
2661                 }
2662                 return TRUE;
2663             }
2664         }
2665     }
2666
2667     if (bktr->current_col <= bktr->line_length) {
2668         bktr->current_col = bktr->line_length;
2669         return TRUE;
2670     }
2671     return FALSE;
2672 }
2673
2674 static bool_t split(bktr_reg_t * bktr, volatile uint32_t **dma_prog, int width ,
2675                     u_long operation, int pixel_width,
2676                     volatile u_char ** target_buffer, int cols ) {
2677
2678  u_long flag, flag2;
2679  struct meteor_pixfmt *pf = &pixfmt_table[ bktr->pixfmt ].public;
2680  u_int  skip, start_skip;
2681
2682   /*  For RGB24, we need to align the component in FIFO Byte Lane 0         */
2683   /*    to the 1st byte in the mem dword containing our start addr.         */
2684   /*    BTW, we know this pixfmt's 1st byte is Blue; thus the start addr    */
2685   /*     must be Blue.                                                      */
2686   start_skip = 0;
2687   if (( pf->type == METEOR_PIXTYPE_RGB ) && ( pf->Bpp == 3 ))
2688           switch ( ((uintptr_t) (volatile void *) *target_buffer) % 4 ) {
2689           case 2 : start_skip = 4 ; break;
2690           case 1 : start_skip = 8 ; break;
2691           }
2692
2693  if ((width * pixel_width) < DMA_BT848_SPLIT ) {
2694      if (  width == cols) {
2695          flag = OP_SOL | OP_EOL;
2696        } else if (bktr->current_col == 0 ) {
2697             flag  = OP_SOL;
2698        } else if (bktr->current_col == cols) {
2699             flag = OP_EOL;
2700        } else flag = 0;
2701
2702      skip = 0;
2703      if (( flag & OP_SOL ) && ( start_skip > 0 )) {
2704              *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip;
2705              flag &= ~OP_SOL;
2706              skip = start_skip;
2707      }
2708
2709      *(*dma_prog)++ = operation | flag  | (width * pixel_width - skip);
2710      if (operation != OP_SKIP )
2711          *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer;
2712
2713      *target_buffer += width * pixel_width;
2714      bktr->current_col += width;
2715
2716  } else {
2717
2718         if (bktr->current_col == 0 && width == cols) {
2719             flag = OP_SOL ;
2720             flag2 = OP_EOL;
2721         } else if (bktr->current_col == 0 ) {
2722             flag = OP_SOL;
2723             flag2 = 0;
2724         } else if (bktr->current_col >= cols)  {
2725             flag =  0;
2726             flag2 = OP_EOL;
2727         } else {
2728             flag =  0;
2729             flag2 = 0;
2730         }
2731
2732         skip = 0;
2733         if (( flag & OP_SOL ) && ( start_skip > 0 )) {
2734                 *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip;
2735                 flag &= ~OP_SOL;
2736                 skip = start_skip;
2737         }
2738
2739         *(*dma_prog)++ = operation  | flag |
2740               (width * pixel_width / 2 - skip);
2741         if (operation != OP_SKIP )
2742               *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer ;
2743         *target_buffer +=  (width * pixel_width / 2) ;
2744
2745         if ( operation == OP_WRITE )
2746                 operation = OP_WRITEC;
2747         *(*dma_prog)++ = operation | flag2 |
2748             (width * pixel_width / 2);
2749         *target_buffer +=  (width * pixel_width / 2) ;
2750           bktr->current_col += width;
2751
2752     }
2753  return TRUE;
2754 }
2755
2756
2757 /*
2758  * Generate the RISC instructions to capture both VBI and video images
2759  */
2760 static void
2761 rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
2762 {
2763         int                     i;
2764         volatile uint32_t       target_buffer, buffer, target,width;
2765         volatile uint32_t       pitch;
2766         volatile uint32_t       *dma_prog;      /* DMA prog is an array of
2767                                                 32 bit RISC instructions */
2768         volatile uint32_t       *loop_point;
2769         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2770         u_int                   Bpp = pf_int->public.Bpp;
2771         unsigned int            vbisamples;     /* VBI samples per line */
2772         unsigned int            vbilines;       /* VBI lines per field */
2773         unsigned int            num_dwords;     /* DWORDS per line */
2774
2775         vbisamples = format_params[bktr->format_params].vbi_num_samples;
2776         vbilines   = format_params[bktr->format_params].vbi_num_lines;
2777         num_dwords = vbisamples/4;
2778
2779         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2780         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2781         OUTB(bktr, BKTR_VBI_PACK_SIZE, ((num_dwords)) & 0xff);
2782         OUTB(bktr, BKTR_VBI_PACK_DEL, ((num_dwords)>> 8) & 0x01); /* no hdelay    */
2783                                                             /* no ext frame */
2784
2785         OUTB(bktr, BKTR_OFORM, 0x00);
2786
2787         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2788         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2789         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2790         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2791
2792         /* disable gamma correction removal */
2793         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2794
2795         if (cols > 385 ) {
2796             OUTB(bktr, BKTR_E_VTC, 0);
2797             OUTB(bktr, BKTR_O_VTC, 0);
2798         } else {
2799             OUTB(bktr, BKTR_E_VTC, 1);
2800             OUTB(bktr, BKTR_O_VTC, 1);
2801         }
2802         bktr->capcontrol = 3 << 2 |  3;
2803
2804         dma_prog = (uint32_t *) bktr->dma_prog;
2805
2806         /* Construct Write */
2807
2808         if (bktr->video.addr) {
2809                 target_buffer = (u_long) bktr->video.addr;
2810                 pitch = bktr->video.width;
2811         }
2812         else {
2813                 target_buffer = (u_long) vtophys(bktr->bigbuf);
2814                 pitch = cols*Bpp;
2815         }
2816
2817         buffer = target_buffer;
2818
2819         /* Wait for the VRE sync marking the end of the Even and
2820          * the start of the Odd field. Resync here.
2821          */
2822         *dma_prog++ = OP_SYNC | BKTR_RESYNC |BKTR_VRE;
2823         *dma_prog++ = 0;
2824
2825         loop_point = dma_prog;
2826
2827         /* store the VBI data */
2828         /* look for sync with packed data */
2829         *dma_prog++ = OP_SYNC | BKTR_FM1;
2830         *dma_prog++ = 0;
2831         for(i = 0; i < vbilines; i++) {
2832                 *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples;
2833                 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
2834                                         (i * VBI_LINE_SIZE));
2835         }
2836
2837         if ( (i_flag == 2/*Odd*/) || (i_flag==3) /*interlaced*/ ) {
2838                 /* store the Odd field video image */
2839                 /* look for sync with packed data */
2840                 *dma_prog++ = OP_SYNC  | BKTR_FM1;
2841                 *dma_prog++ = 0;  /* NULL WORD */
2842                 width = cols;
2843                 for (i = 0; i < (rows/interlace); i++) {
2844                     target = target_buffer;
2845                     if ( notclipped(bktr, i, width)) {
2846                         split(bktr, (volatile uint32_t **) &dma_prog,
2847                               bktr->y2 - bktr->y, OP_WRITE,
2848                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2849
2850                     } else {
2851                         while(getline(bktr, i)) {
2852                             if (bktr->y != bktr->y2 ) {
2853                                 split(bktr, (volatile uint32_t **) &dma_prog,
2854                                       bktr->y2 - bktr->y, OP_WRITE,
2855                                       Bpp, (volatile u_char **)(uintptr_t)&target, cols);
2856                             }
2857                             if (bktr->yclip != bktr->yclip2 ) {
2858                                 split(bktr,(volatile uint32_t **) &dma_prog,
2859                                       bktr->yclip2 - bktr->yclip,
2860                                       OP_SKIP,
2861                                       Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2862                             }
2863                         }
2864
2865                     }
2866
2867                     target_buffer += interlace * pitch;
2868
2869                 }
2870
2871         } /* end if */
2872
2873         /* Grab the Even field */
2874         /* Look for the VRO, end of Odd field, marker */
2875         *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
2876         *dma_prog++ = 0;  /* NULL WORD */
2877
2878         /* store the VBI data */
2879         /* look for sync with packed data */
2880         *dma_prog++ = OP_SYNC | BKTR_FM1;
2881         *dma_prog++ = 0;
2882         for(i = 0; i < vbilines; i++) {
2883                 *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples;
2884                 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
2885                                 ((i+MAX_VBI_LINES) * VBI_LINE_SIZE));
2886         }
2887
2888         /* store the video image */
2889         if (i_flag == 1) /*Even Only*/
2890                 target_buffer = buffer;
2891         if (i_flag == 3) /*interlaced*/
2892                 target_buffer = buffer+pitch;
2893
2894
2895         if ((i_flag == 1) /*Even Only*/ || (i_flag==3) /*interlaced*/) {
2896                 /* look for sync with packed data */
2897                 *dma_prog++ = OP_SYNC | BKTR_FM1;
2898                 *dma_prog++ = 0;  /* NULL WORD */
2899                 width = cols;
2900                 for (i = 0; i < (rows/interlace); i++) {
2901                     target = target_buffer;
2902                     if ( notclipped(bktr, i, width)) {
2903                         split(bktr, (volatile uint32_t **) &dma_prog,
2904                               bktr->y2 - bktr->y, OP_WRITE,
2905                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
2906                     } else {
2907                         while(getline(bktr, i)) {
2908                             if (bktr->y != bktr->y2 ) {
2909                                 split(bktr, (volatile uint32_t **) &dma_prog,
2910                                       bktr->y2 - bktr->y, OP_WRITE,
2911                                       Bpp, (volatile u_char **)(uintptr_t)&target,
2912                                       cols);
2913                             }
2914                             if (bktr->yclip != bktr->yclip2 ) {
2915                                 split(bktr, (volatile uint32_t **) &dma_prog,
2916                                       bktr->yclip2 - bktr->yclip, OP_SKIP,
2917                                       Bpp, (volatile u_char **)(uintptr_t) &target,  cols);
2918                             }
2919
2920                         }
2921
2922                     }
2923
2924                     target_buffer += interlace * pitch;
2925
2926                 }
2927         }
2928
2929         /* Look for end of 'Even Field' */
2930         *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE;
2931         *dma_prog++ = 0;  /* NULL WORD */
2932
2933         *dma_prog++ = OP_JUMP ;
2934         *dma_prog++ = (u_long ) vtophys(loop_point) ;
2935         *dma_prog++ = 0;  /* NULL WORD */
2936
2937 }
2938
2939
2940
2941
2942 static void
2943 rgb_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
2944 {
2945         int                     i;
2946         volatile uint32_t               target_buffer, buffer, target,width;
2947         volatile uint32_t       pitch;
2948         volatile  uint32_t      *dma_prog;
2949         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
2950         u_int                   Bpp = pf_int->public.Bpp;
2951
2952         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
2953         OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
2954         OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
2955         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
2956
2957         OUTB(bktr, BKTR_OFORM, 0x00);
2958
2959         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
2960         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
2961         OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
2962         OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
2963
2964         /* disable gamma correction removal */
2965         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
2966
2967         if (cols > 385 ) {
2968             OUTB(bktr, BKTR_E_VTC, 0);
2969             OUTB(bktr, BKTR_O_VTC, 0);
2970         } else {
2971             OUTB(bktr, BKTR_E_VTC, 1);
2972             OUTB(bktr, BKTR_O_VTC, 1);
2973         }
2974         bktr->capcontrol = 3 << 2 |  3;
2975
2976         dma_prog = (uint32_t *) bktr->dma_prog;
2977
2978         /* Construct Write */
2979
2980         if (bktr->video.addr) {
2981                 target_buffer = (uint32_t) bktr->video.addr;
2982                 pitch = bktr->video.width;
2983         }
2984         else {
2985                 target_buffer = (uint32_t) vtophys(bktr->bigbuf);
2986                 pitch = cols*Bpp;
2987         }
2988
2989         buffer = target_buffer;
2990
2991         /* contruct sync : for video packet format */
2992         *dma_prog++ = OP_SYNC  | BKTR_RESYNC | BKTR_FM1;
2993
2994         /* sync, mode indicator packed data */
2995         *dma_prog++ = 0;  /* NULL WORD */
2996         width = cols;
2997         for (i = 0; i < (rows/interlace); i++) {
2998             target = target_buffer;
2999             if ( notclipped(bktr, i, width)) {
3000                 split(bktr, (volatile uint32_t **) &dma_prog,
3001                       bktr->y2 - bktr->y, OP_WRITE,
3002                       Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
3003
3004             } else {
3005                 while(getline(bktr, i)) {
3006                     if (bktr->y != bktr->y2 ) {
3007                         split(bktr, (volatile uint32_t **) &dma_prog,
3008                               bktr->y2 - bktr->y, OP_WRITE,
3009                               Bpp, (volatile u_char **)(uintptr_t)&target, cols);
3010                     }
3011                     if (bktr->yclip != bktr->yclip2 ) {
3012                         split(bktr,(volatile uint32_t **) &dma_prog,
3013                               bktr->yclip2 - bktr->yclip,
3014                               OP_SKIP,
3015                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
3016                     }
3017                 }
3018
3019             }
3020
3021             target_buffer += interlace * pitch;
3022
3023         }
3024
3025         switch (i_flag) {
3026         case 1:
3027                 /* sync vre */
3028                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO;
3029                 *dma_prog++ = 0;  /* NULL WORD */
3030
3031                 *dma_prog++ = OP_JUMP;
3032                 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog);
3033                 return;
3034
3035         case 2:
3036                 /* sync vro */
3037                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE;
3038                 *dma_prog++ = 0;  /* NULL WORD */
3039
3040                 *dma_prog++ = OP_JUMP;
3041                 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog);
3042                 return;
3043
3044         case 3:
3045                 /* sync vro */
3046                 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
3047                 *dma_prog++ = 0;  /* NULL WORD */
3048                 *dma_prog++ = OP_JUMP;
3049                 *dma_prog = (uint32_t ) vtophys(bktr->odd_dma_prog);
3050                 break;
3051         }
3052
3053         if (interlace == 2) {
3054
3055                 target_buffer = buffer + pitch;
3056
3057                 dma_prog = (uint32_t *) bktr->odd_dma_prog;
3058
3059                 /* sync vre IRQ bit */
3060                 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1;
3061                 *dma_prog++ = 0;  /* NULL WORD */
3062                 width = cols;
3063                 for (i = 0; i < (rows/interlace); i++) {
3064                     target = target_buffer;
3065                     if ( notclipped(bktr, i, width)) {
3066                         split(bktr, (volatile uint32_t **) &dma_prog,
3067                               bktr->y2 - bktr->y, OP_WRITE,
3068                               Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
3069                     } else {
3070                         while(getline(bktr, i)) {
3071                             if (bktr->y != bktr->y2 ) {
3072                                 split(bktr, (volatile uint32_t **) &dma_prog,
3073                                       bktr->y2 - bktr->y, OP_WRITE,
3074                                       Bpp, (volatile u_char **)(uintptr_t)&target,
3075                                       cols);
3076                             }
3077                             if (bktr->yclip != bktr->yclip2 ) {
3078                                 split(bktr, (volatile uint32_t **) &dma_prog,
3079                                       bktr->yclip2 - bktr->yclip, OP_SKIP,
3080                                       Bpp, (volatile u_char **)(uintptr_t)&target,  cols);
3081                             }
3082
3083                         }
3084
3085                     }
3086
3087                     target_buffer += interlace * pitch;
3088
3089                 }
3090         }
3091
3092         /* sync vre IRQ bit */
3093         *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE;
3094         *dma_prog++ = 0;  /* NULL WORD */
3095         *dma_prog++ = OP_JUMP ;
3096         *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog) ;
3097         *dma_prog++ = 0;  /* NULL WORD */
3098 }
3099
3100
3101 /*
3102  *
3103  */
3104 static void
3105 yuvpack_prog( bktr_ptr_t bktr, char i_flag,
3106               int cols, int rows, int interlace )
3107 {
3108         int                     i;
3109         volatile unsigned int   inst;
3110         volatile unsigned int   inst3;
3111         volatile uint32_t       target_buffer, buffer;
3112         volatile  uint32_t      *dma_prog;
3113         struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
3114         int                     b;
3115
3116         OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
3117
3118         OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* enable chroma comb */
3119         OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
3120
3121         OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_RGB_DED | BT848_COLOR_CTL_GAMMA);
3122         OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
3123
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