Latest bktr driver from FreeBSD; thanks to Andres Gunnarsson

<andreas@crt.se> for testing.

11 files changed, 10062 insertions, 0 deletions

diff --git a/sys/dev/pci/bktr/bktr_audio.c b/sys/dev/pci/bktr/bktr_audio.c
new file mode 100644
index 00000000000..1f437c4e527
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_audio.c
@@ -0,0 +1,634 @@
+/*	$OpenBSD: bktr_audio.c,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_audio.c,v 1.8 2000/10/31 13:09:56 roger Exp $ */
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_audio : This deals with controlling the audio on TV cards,
+ *                controlling the Audio Multiplexer (audio source selector).
+ *                controlling any MSP34xx stereo audio decoders.
+ *                controlling any DPL35xx dolby surroud sound audio decoders.    
+ *                initialising TDA98xx audio devices.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/vnode.h>
+
+#ifdef __FreeBSD__
+
+#if (__FreeBSD_version < 500000)
+#include <machine/clock.h>              /* for DELAY */
+#endif
+
+#include <pci/pcivar.h>
+
+#if (__FreeBSD_version >=300000)
+#include <machine/bus_memio.h>		/* for bus space */
+#include <machine/bus.h>
+#include <sys/bus.h>
+#endif
+#endif
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/proc.h>
+#include <dev/ic/bt8xx.h>	/* NetBSD location of .h files */
+#include <dev/pci/bktr/bktr_reg.h>
+#include <dev/pci/bktr/bktr_core.h>
+#include <dev/pci/bktr/bktr_tuner.h>
+#include <dev/pci/bktr/bktr_card.h>
+#include <dev/pci/bktr/bktr_audio.h>
+#else
+#include <machine/ioctl_meteor.h>	/* Traditional location of .h files */
+#include <machine/ioctl_bt848.h>        /* extensions to ioctl_meteor.h */
+#include <dev/bktr/bktr_reg.h>
+#include <dev/bktr/bktr_core.h>
+#include <dev/bktr/bktr_tuner.h>
+#include <dev/bktr/bktr_card.h>
+#include <dev/bktr/bktr_audio.h>
+#endif
+
+/*
+ * Prototypes for the GV_BCTV specific functions.
+ */
+void    set_bctv_audio( bktr_ptr_t bktr );
+void    bctv_gpio_write( bktr_ptr_t bktr, int port, int val );
+/*int   bctv_gpio_read( bktr_ptr_t bktr, int port );*/ /* Not used */
+
+
+
+/*
+ * init_audio_devices
+ * Reset any MSP34xx or TDA98xx audio devices.
+ */
+void init_audio_devices( bktr_ptr_t bktr ) {
+
+        /* enable stereo if appropriate on TDA audio chip */
+        if ( bktr->card.dbx )
+                init_BTSC( bktr );
+ 
+        /* reset the MSP34xx stereo audio chip */
+        if ( bktr->card.msp3400c )
+                msp_dpl_reset( bktr, bktr->msp_addr );
+
+        /* reset the DPL35xx dolby audio chip */
+        if ( bktr->card.dpl3518a )
+                msp_dpl_reset( bktr, bktr->dpl_addr );
+
+}
+
+
+/*
+ * 
+ */
+#define AUDIOMUX_DISCOVER_NOT
+int
+set_audio( bktr_ptr_t bktr, int cmd )
+{
+	u_long		temp;
+	volatile u_char	idx;
+
+#if defined( AUDIOMUX_DISCOVER )
+	if ( cmd >= 200 )
+		cmd -= 200;
+	else
+#endif /* AUDIOMUX_DISCOVER */
+
+	/* check for existance of audio MUXes */
+	if ( !bktr->card.audiomuxs[ 4 ] )
+		return( -1 );
+
+	switch (cmd) {
+	case AUDIO_TUNER:
+#ifdef BKTR_REVERSEMUTE
+		bktr->audio_mux_select = 3;
+#else
+		bktr->audio_mux_select = 0;
+#endif
+
+		if (bktr->reverse_mute ) 
+		      bktr->audio_mux_select = 0;
+		else	
+		    bktr->audio_mux_select = 3;
+
+		break;
+	case AUDIO_EXTERN:
+		bktr->audio_mux_select = 1;
+		break;
+	case AUDIO_INTERN:
+		bktr->audio_mux_select = 2;
+		break;
+	case AUDIO_MUTE:
+		bktr->audio_mute_state = TRUE;	/* set mute */
+		break;
+	case AUDIO_UNMUTE:
+		bktr->audio_mute_state = FALSE;	/* clear mute */
+		break;
+	default:
+		printf("%s: audio cmd error %02x\n", bktr_name(bktr),
+		       cmd);
+		return( -1 );
+	}
+
+
+	/* Most cards have a simple audio multiplexer to select the
+	 * audio source. The I/O_GV card has a more advanced multiplexer
+	 * and requires special handling.
+	 */
+        if ( bktr->bt848_card == CARD_IO_GV ) {
+                set_bctv_audio( bktr );
+                return( 0 );
+	}
+
+	/* Proceed with the simpler audio multiplexer code for the majority
+	 * of Bt848 cards.
+	 */
+
+	/*
+	 * Leave the upper bits of the GPIO port alone in case they control
+	 * something like the dbx or teletext chips.  This doesn't guarantee
+	 * success, but follows the rule of least astonishment.
+	 */
+
+	if ( bktr->audio_mute_state == TRUE ) {
+#ifdef BKTR_REVERSEMUTE
+		idx = 0;
+#else
+		idx = 3;
+#endif
+
+		if (bktr->reverse_mute )
+		  idx  = 3;
+		else	
+		  idx  = 0;
+
+	}
+	else
+		idx = bktr->audio_mux_select;
+
+
+	temp = INL(bktr, BKTR_GPIO_DATA) & ~bktr->card.gpio_mux_bits;
+#if defined( AUDIOMUX_DISCOVER )
+	OUTL(bktr, BKTR_GPIO_DATA, temp | (cmd & 0xff));
+	printf("%s: cmd: %d audio mux %x temp %x \n", bktr_name(bktr),
+	  	cmd, bktr->card.audiomuxs[ idx ], temp );
+#else
+	OUTL(bktr, BKTR_GPIO_DATA, temp | bktr->card.audiomuxs[ idx ]);
+#endif /* AUDIOMUX_DISCOVER */
+
+
+
+	/* Some new Hauppauge cards do not have an audio mux */
+	/* Instead we use the MSP34xx chip to select TV audio, Line-In */
+	/* FM Radio and Mute */
+	/* Examples of this are the Hauppauge 44xxx MSP34xx models */
+	/* It is ok to drive both the mux and the MSP34xx chip. */
+	/* If there is no mux, the MSP does the switching of the audio source */
+	/* If there is a mux, it does the switching of the audio source */
+
+	if ((bktr->card.msp3400c) && (bktr->audio_mux_present == 0)) {
+
+	  if (bktr->audio_mute_state == TRUE ) {
+		 msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000, 0x0000); /* volume to MUTE */
+	  } else {
+		 if(bktr->audio_mux_select == 0) { /* TV Tuner */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000, 0x7300); /* 0 db volume */
+		    if (bktr->msp_source_selected != 0) msp_autodetect(bktr);  /* setup TV audio mode */
+		    bktr->msp_source_selected = 0;
+		 }
+		 if(bktr->audio_mux_select == 1) { /* Line In */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000, 0x7300); /* 0 db volume */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000d, 0x1900); /* scart prescale */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008, 0x0220); /* SCART | STEREO */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0013, 0x0000); /* DSP In = SC1_IN_L/R */
+		    bktr->msp_source_selected = 1;
+		 }
+
+		 if(bktr->audio_mux_select == 2) { /* FM Radio */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000, 0x7300); /* 0 db volume */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000d, 0x1900); /* scart prescale */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008, 0x0220); /* SCART | STEREO */
+		    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0013, 0x0200); /* DSP In = SC2_IN_L/R */
+		    bktr->msp_source_selected = 2;
+		 }
+	  }
+	}
+
+
+	return( 0 );
+}
+
+
+/*
+ * 
+ */
+void
+temp_mute( bktr_ptr_t bktr, int flag )
+{
+	static int	muteState = FALSE;
+
+	if ( flag == TRUE ) {
+		muteState = bktr->audio_mute_state;
+		set_audio( bktr, AUDIO_MUTE );		/* prevent 'click' */
+	}
+	else {
+		tsleep( BKTR_SLEEP, PZERO, "tuning", hz/8 );
+		if ( muteState == FALSE )
+			set_audio( bktr, AUDIO_UNMUTE );
+	}
+}
+
+/* address of BTSC/SAP decoder chip */
+#define TDA9850_WADDR           0xb6
+#define TDA9850_RADDR           0xb7
+
+
+/* registers in the TDA9850 BTSC/dbx chip */
+#define CON1ADDR                0x04
+#define CON2ADDR                0x05
+#define CON3ADDR                0x06 
+#define CON4ADDR                0x07
+#define ALI1ADDR                0x08 
+#define ALI2ADDR                0x09
+#define ALI3ADDR                0x0a
+
+/*
+ * initialise the dbx chip
+ * taken from the Linux bttv driver TDA9850 initialisation code
+ */
+void 
+init_BTSC( bktr_ptr_t bktr )
+{
+    i2cWrite(bktr, TDA9850_WADDR, CON1ADDR, 0x08); /* noise threshold st */
+    i2cWrite(bktr, TDA9850_WADDR, CON2ADDR, 0x08); /* noise threshold sap */
+    i2cWrite(bktr, TDA9850_WADDR, CON3ADDR, 0x40); /* stereo mode */
+    i2cWrite(bktr, TDA9850_WADDR, CON4ADDR, 0x07); /* 0 dB input gain? */
+    i2cWrite(bktr, TDA9850_WADDR, ALI1ADDR, 0x10); /* wideband alignment? */
+    i2cWrite(bktr, TDA9850_WADDR, ALI2ADDR, 0x10); /* spectral alignment? */
+    i2cWrite(bktr, TDA9850_WADDR, ALI3ADDR, 0x03);
+}
+
+/*
+ * setup the dbx chip
+ * XXX FIXME: alot of work to be done here, this merely unmutes it.
+ */
+int
+set_BTSC( bktr_ptr_t bktr, int control )
+{
+	return( i2cWrite( bktr, TDA9850_WADDR, CON3ADDR, control ) );
+}
+
+/*
+ * CARD_GV_BCTV specific functions.
+ */
+
+#define BCTV_AUDIO_MAIN              0x10    /* main audio program */
+#define BCTV_AUDIO_SUB               0x20    /* sub audio program */
+#define BCTV_AUDIO_BOTH              0x30    /* main(L) + sub(R) program */
+
+#define BCTV_GPIO_REG0          1
+#define BCTV_GPIO_REG1          3
+
+#define BCTV_GR0_AUDIO_MODE     3
+#define BCTV_GR0_AUDIO_MAIN     0       /* main program */
+#define BCTV_GR0_AUDIO_SUB      3       /* sub program */
+#define BCTV_GR0_AUDIO_BOTH     1       /* main(L) + sub(R) */
+#define BCTV_GR0_AUDIO_MUTE     4       /* audio mute */
+#define BCTV_GR0_AUDIO_MONO     8       /* force mono */
+
+void
+set_bctv_audio( bktr_ptr_t bktr )
+{
+        int data;
+
+        switch (bktr->audio_mux_select) {
+        case 1:         /* external */
+        case 2:         /* internal */
+                bctv_gpio_write(bktr, BCTV_GPIO_REG1, 0);
+                break;
+        default:        /* tuner */
+                bctv_gpio_write(bktr, BCTV_GPIO_REG1, 1);
+                break;
+        }
+/*      switch (bktr->audio_sap_select) { */
+        switch (BCTV_AUDIO_BOTH) {
+        case BCTV_AUDIO_SUB:
+                data = BCTV_GR0_AUDIO_SUB;
+                break;
+        case BCTV_AUDIO_BOTH:
+                data = BCTV_GR0_AUDIO_BOTH;
+                break;
+        case BCTV_AUDIO_MAIN:
+        default:
+                data = BCTV_GR0_AUDIO_MAIN;
+                break;
+        }
+        if (bktr->audio_mute_state == TRUE)
+                data |= BCTV_GR0_AUDIO_MUTE;
+
+        bctv_gpio_write(bktr, BCTV_GPIO_REG0, data);
+
+        return;
+}
+
+/* gpio_data bit assignment */
+#define BCTV_GPIO_ADDR_MASK     0x000300
+#define BCTV_GPIO_WE            0x000400
+#define BCTV_GPIO_OE            0x000800
+#define BCTV_GPIO_VAL_MASK      0x00f000
+
+#define BCTV_GPIO_PORT_MASK     3
+#define BCTV_GPIO_ADDR_SHIFT    8
+#define BCTV_GPIO_VAL_SHIFT     12
+
+/* gpio_out_en value for read/write */
+#define BCTV_GPIO_OUT_RMASK     0x000f00
+#define BCTV_GPIO_OUT_WMASK     0x00ff00
+
+#define BCTV_BITS       100
+
+void
+bctv_gpio_write( bktr_ptr_t bktr, int port, int val )
+{
+        u_long data, outbits;
+
+        port &= BCTV_GPIO_PORT_MASK;
+        switch (port) {
+        case 1:
+        case 3:
+                data = ((val << BCTV_GPIO_VAL_SHIFT) & BCTV_GPIO_VAL_MASK) |
+                       ((port << BCTV_GPIO_ADDR_SHIFT) & BCTV_GPIO_ADDR_MASK) |
+                       BCTV_GPIO_WE | BCTV_GPIO_OE;
+                outbits = BCTV_GPIO_OUT_WMASK;
+                break;
+        default:
+                return;
+        }
+        OUTL(bktr, BKTR_GPIO_OUT_EN, 0);
+        OUTL(bktr, BKTR_GPIO_DATA, data);
+        OUTL(bktr, BKTR_GPIO_OUT_EN, outbits);
+        DELAY(BCTV_BITS);
+        OUTL(bktr, BKTR_GPIO_DATA, data & ~BCTV_GPIO_WE);
+        DELAY(BCTV_BITS);
+        OUTL(bktr, BKTR_GPIO_DATA, data);
+        DELAY(BCTV_BITS);
+        OUTL(bktr, BKTR_GPIO_DATA, ~0);
+        OUTL(bktr, BKTR_GPIO_OUT_EN, 0);
+}
+
+/* Not yet used
+int
+bctv_gpio_read( bktr_ptr_t bktr, int port )
+{
+        u_long data, outbits, ret;
+
+        port &= BCTV_GPIO_PORT_MASK;
+        switch (port) {
+        case 1:
+        case 3:
+                data = ((port << BCTV_GPIO_ADDR_SHIFT) & BCTV_GPIO_ADDR_MASK) |
+                       BCTV_GPIO_WE | BCTV_GPIO_OE;
+                outbits = BCTV_GPIO_OUT_RMASK;
+                break;
+        default:
+                return( -1 );
+        }
+        OUTL(bktr, BKTR_GPIO_OUT_EN, 0);
+        OUTL(bktr, BKTR_GPIO_DATA, data);
+        OUTL(bktr, BKTR_GPIO_OUT_EN, outbits);
+        DELAY(BCTV_BITS);
+        OUTL(bktr, BKTR_GPIO_DATA, data & ~BCTV_GPIO_OE);
+        DELAY(BCTV_BITS);
+        ret = INL(bktr, BKTR_GPIO_DATA);
+        DELAY(BCTV_BITS);
+        OUTL(bktr, BKTR_GPIO_DATA, data);
+        DELAY(BCTV_BITS);
+        OUTL(bktr, BKTR_GPIO_DATA, ~0);
+        OUTL(bktr, BKTR_GPIO_OUT_EN, 0);
+        return( (ret & BCTV_GPIO_VAL_MASK) >> BCTV_GPIO_VAL_SHIFT );
+}
+*/
+
+/*
+ * setup the MSP34xx Stereo Audio Chip
+ * This uses the Auto Configuration Option on MSP3410D and MSP3415D chips
+ * and DBX mode selection for MSP3430G chips.
+ * For MSP3400C support, the full programming sequence is required and is
+ * not yet supported.
+ */
+
+/* Read the MSP version string */
+void msp_read_id( bktr_ptr_t bktr ){
+    int rev1=0, rev2=0;
+    rev1 = msp_dpl_read(bktr, bktr->msp_addr, 0x12, 0x001e);
+    rev2 = msp_dpl_read(bktr, bktr->msp_addr, 0x12, 0x001f);
+
+    sprintf(bktr->msp_version_string, "34%02d%c-%c%d",
+      (rev2>>8)&0xff, (rev1&0xff)+'@', ((rev1>>8)&0xff)+'@', rev2&0x1f);
+
+}
+
+
+/* Configure the MSP chip to Auto-detect the audio format.
+ * For the MSP3430G, we use fast autodetect mode
+ * For the MSP3410/3415 there are two schemes for this
+ *  a) Fast autodetection - the chip is put into autodetect mode, and the function
+ *     returns immediatly. This works in most cases and is the Default Mode.
+ *  b) Slow mode. The function sets the MSP3410/3415 chip, then waits for feedback from 
+ *     the chip and re-programs it if needed.
+ */
+void msp_autodetect( bktr_ptr_t bktr ) {
+  int auto_detect, loops;
+  int stereo;
+
+  /* MSP3430G - countries with mono and DBX stereo */
+  if (strncmp("3430G", bktr->msp_version_string, 5) == 0){
+
+    msp_dpl_write(bktr, bktr->msp_addr, 0x10, 0x0030,0x2003);/* Enable Auto format detection */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x10, 0x0020,0x0020);/* Standard Select Reg. = BTSC-Stereo*/
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000E,0x2403);/* darned if I know */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008,0x0320);/* Source select = (St or A) */
+					                     /* & Ch. Matrix = St */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000,0x7300);/* Set volume to 0db gain */
+  }
+
+
+  /* MSP3415D SPECIAL CASE Use the Tuner's Mono audio ouput for the MSP */
+  /* (for Hauppauge 44xxx card with Tuner Type 0x2a) */
+  else if (  ( (strncmp("3415D", bktr->msp_version_string, 5) == 0)
+               &&(bktr->msp_use_mono_source == 1)
+              )
+           || (bktr->slow_msp_audio == 2) ){
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000, 0x7300); /* 0 db volume */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000d, 0x1900); /* scart prescale */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008, 0x0220); /* SCART | STEREO */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0013, 0x0100); /* DSP In = MONO IN */
+  }
+
+
+  /* MSP3410/MSP3415 - countries with mono, stereo using 2 FM channels and NICAM */
+  /* FAST sound scheme */
+  else if (bktr->slow_msp_audio == 0) {
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000,0x7300);/* Set volume to 0db gain */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008,0x0000);/* Spkr Source = default(FM/AM) */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x10, 0x0020,0x0001);/* Enable Auto format detection */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x10, 0x0021,0x0001);/* Auto selection of NICAM/MONO mode */
+  }
+
+
+  /* MSP3410/MSP3415 - European Countries where the fast MSP3410/3415 programming fails */
+  /* SLOW sound scheme */
+  else if ( bktr->slow_msp_audio == 1) {
+    msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0000,0x7300);/* Set volume to 0db gain */
+    msp_dpl_write(bktr, bktr->msp_addr, 0x10, 0x0020,0x0001);/* Enable Auto format detection */
+    
+    /* wait for 0.5s max for terrestrial sound autodetection */
+    loops = 10;
+    do {
+      DELAY(100000);
+      auto_detect = msp_dpl_read(bktr, bktr->msp_addr, 0x10, 0x007e);
+      loops++;
+    } while (auto_detect > 0xff && loops < 50);
+    if (bootverbose)printf ("%s: Result of autodetect after %dms: %d\n",
+			    bktr_name(bktr), loops*10, auto_detect);
+
+    /* Now set the audio baseband processing */
+    switch (auto_detect) {
+    case 0:                    /* no TV sound standard detected */
+      break;
+    case 2:                    /* M Dual FM */
+      break;
+    case 3:                    /* B/G Dual FM; German stereo */
+      /* Read the stereo detection value from DSP reg 0x0018 */
+      DELAY(20000);
+      stereo = msp_dpl_read(bktr, bktr->msp_addr, 0x12, 0x0018);
+      if (bootverbose)printf ("%s: Stereo reg 0x18 a: %d\n",
+			      bktr_name(bktr), stereo);
+      DELAY(20000);
+      stereo = msp_dpl_read(bktr, bktr->msp_addr, 0x12, 0x0018);
+      if (bootverbose)printf ("%s: Stereo reg 0x18 b: %d\n",
+			      bktr_name(bktr), stereo); 
+      DELAY(20000); 
+      stereo = msp_dpl_read(bktr, bktr->msp_addr, 0x12, 0x0018);
+      if (bootverbose)printf ("%s: Stereo reg 0x18 c: %d\n",
+			      bktr_name(bktr), stereo);
+      if (stereo > 0x0100 && stereo < 0x8000) { /* Seems to be stereo */
+        msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008,0x0020);/* Loudspeaker set stereo*/
+        /*
+          set spatial effect strength to 50% enlargement
+          set spatial effect mode b, stereo basewidth enlargment only
+        */
+        msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0005,0x3f28);
+      } else if (stereo > 0x8000) {    /* bilingual mode */
+        if (bootverbose) printf ("%s: Bilingual mode detected\n",
+				 bktr_name(bktr));
+        msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008,0x0000);/* Loudspeaker */
+        msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0005,0x0000);/* all spatial effects off */
+       } else {                 /* must be mono */
+        msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008,0x0030);/* Loudspeaker */
+        /*
+          set spatial effect strength to 50% enlargement
+          set spatial effect mode a, stereo basewidth enlargment
+          and pseudo stereo effect with automatic high-pass filter
+        */
+        msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0005,0x3f08);
+      }
+#if 0
+       /* The reset value for Channel matrix mode is FM/AM and SOUNDA/LEFT */
+       /* We would like STEREO instead val: 0x0020 */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0008,0x0020);/* Loudspeaker */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0009,0x0020);/* Headphone */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000a,0x0020);/* SCART1 */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0041,0x0020);/* SCART2 */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000b,0x0020);/* I2S */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000c,0x0020);/* Quasi-Peak Detector Source */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x000e,0x0001);
+#endif
+      break;
+    case 8:                    /* B/G FM NICAM */
+       msp_dpl_write(bktr, bktr->msp_addr, 0x10, 0x0021,0x0001);/* Auto selection of NICAM/MONO mode */
+       break;
+     case 9:                    /* L_AM NICAM or D/K*/
+     case 10:                   /* i-FM NICAM */
+       break;
+     default:
+       if (bootverbose) printf ("%s: Unknown autodetection result value: %d\n",
+				bktr_name(bktr), auto_detect); 
+     }
+
+  }
+
+
+  /* uncomment the following line to enable the MSP34xx 1Khz Tone Generator */
+  /* turn your speaker volume down low before trying this */
+  /* msp_dpl_write(bktr, bktr->msp_addr, 0x12, 0x0014, 0x7f40); */
+}
+
+/* Read the DPL version string */
+void dpl_read_id( bktr_ptr_t bktr ){
+    int rev1=0, rev2=0;
+    rev1 = msp_dpl_read(bktr, bktr->dpl_addr, 0x12, 0x001e);
+    rev2 = msp_dpl_read(bktr, bktr->dpl_addr, 0x12, 0x001f);
+
+    sprintf(bktr->dpl_version_string, "34%02d%c-%c%d",
+      ((rev2>>8)&0xff)-1, (rev1&0xff)+'@', ((rev1>>8)&0xff)+'@', rev2&0x1f);
+}
+
+/* Configure the DPL chip to Auto-detect the audio format */
+void dpl_autodetect( bktr_ptr_t bktr ) {
+
+    /* The following are empiric values tried from the DPL35xx data sheet */
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x000c,0x0320);	/* quasi peak detector source dolby
+								lr 0x03xx; quasi peak detector matrix
+								stereo 0xXX20 */
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x0040,0x0060);	/* Surround decoder mode;
+								ADAPTIVE/3D-PANORAMA, that means two
+								speakers and no center speaker, all
+								channels L/R/C/S mixed to L and R */
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x0041,0x0620);	/* surround source matrix;I2S2/STEREO*/
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x0042,0x1F00);	/* surround delay 31ms max */
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x0043,0x0000);	/* automatic surround input balance */
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x0044,0x4000);	/* surround spatial effect 50%
+								recommended*/
+    msp_dpl_write(bktr, bktr->dpl_addr, 0x12, 0x0045,0x5400);	/* surround panorama effect 66%
+								recommended with PANORAMA mode
+								in 0x0040 set to panorama */
+}
+
diff --git a/sys/dev/pci/bktr/bktr_audio.h b/sys/dev/pci/bktr/bktr_audio.h
new file mode 100644
index 00000000000..6ecae8ca919
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_audio.h
@@ -0,0 +1,85 @@
+/*	$OpenBSD: bktr_audio.h,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_audio.h,v 1.2 1999/10/28 13:58:14 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_audio : This deals with controlling the audio on TV cards,
+ *                controlling the Audio Multiplexer (audio source selector).
+ *                controlling any MSP34xx stereo audio decoders.
+ *                controlling any DPL35xx dolby surroud sound audio decoders.
+ *                initialising TDA98xx audio devices.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Select Audio source, and allow muting
+ */
+int	set_audio( bktr_ptr_t bktr, int mode );
+void	temp_mute( bktr_ptr_t bktr, int flag );
+
+
+/*
+ * Initialise any MSP or TDA devices
+ */
+void	init_audio_devices( bktr_ptr_t bktr );
+
+
+/*
+ * MSP34xx Audio Chip functions.
+ */
+void	msp_autodetect( bktr_ptr_t bktr );
+void	msp_read_id( bktr_ptr_t bktr );
+
+
+/*
+ * DPL35xx Audio Chip functions.
+ */
+void	dpl_autodetect( bktr_ptr_t bktr );
+void	dpl_read_id( bktr_ptr_t bktr );
+
+
+/*
+ * TDA98xx Audio Chip functions.
+ */
+void	init_BTSC( bktr_ptr_t bktr ); 
+int	set_BTSC( bktr_ptr_t bktr, int control );
+
+
+
diff --git a/sys/dev/pci/bktr/bktr_card.c b/sys/dev/pci/bktr/bktr_card.c
new file mode 100644
index 00000000000..843aaf49330
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_card.c
@@ -0,0 +1,1268 @@
+/*	$OpenBSD: bktr_card.c,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_card.c,v 1.16 2000/10/31 13:09:56 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_card : This deals with identifying TV cards.
+ *               trying to find the card make and model of card.
+ *               trying to find the type of tuner fitted.
+ *               reading the configuration EEPROM.
+ *               locating i2c devices.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __OpenBSD__
+#include "opt_bktr.h"		/* Include any kernel config options */
+#endif
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/vnode.h>
+
+#ifdef __FreeBSD__
+
+#if (__FreeBSD_version < 500000)
+#include <machine/clock.h>              /* for DELAY */
+#endif
+
+#include <pci/pcivar.h>
+
+#if (__FreeBSD_version >=300000)
+#include <machine/bus_memio.h>	/* for bus space */
+#include <machine/bus.h>
+#include <sys/bus.h>
+#endif
+#endif
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <dev/ic/bt8xx.h>	/* NetBSD location for .h files */
+#include <dev/pci/bktr/bktr_reg.h>
+#include <dev/pci/bktr/bktr_core.h>
+#include <dev/pci/bktr/bktr_tuner.h>
+#include <dev/pci/bktr/bktr_card.h>
+#include <dev/pci/bktr/bktr_audio.h>
+#else
+#include <machine/ioctl_meteor.h>	/* Traditional location for .h files */
+#include <machine/ioctl_bt848.h>        /* extensions to ioctl_meteor.h */
+#include <dev/bktr/bktr_reg.h>
+#include <dev/bktr/bktr_core.h>
+#include <dev/bktr/bktr_tuner.h>
+#include <dev/bktr/bktr_card.h>
+#include <dev/bktr/bktr_audio.h>
+#endif
+
+/* Include the PCI Vendor definitions */
+#ifdef __NetBSD__
+#include <dev/pci/pcidevs.h>
+#include <dev/pci/pcireg.h>
+#endif
+
+/* Various defines */
+#define HAUP_REMOTE_INT_WADDR   0x30
+#define HAUP_REMOTE_INT_RADDR   0x31
+ 
+#define HAUP_REMOTE_EXT_WADDR   0x34
+#define HAUP_REMOTE_EXT_RADDR   0x35
+
+/* address of BTSC/SAP decoder chip */
+#define TDA9850_WADDR           0xb6 
+#define TDA9850_RADDR           0xb7
+ 
+/* address of MSP3400C chip */
+#define MSP3400C_WADDR          0x80
+#define MSP3400C_RADDR          0x81
+ 
+/* address of DPL3518A chip */
+#define DPL3518A_WADDR          0x84
+#define DPL3518A_RADDR          0x85
+ 
+/* EEProm (128 * 8) on an STB card */
+#define X24C01_WADDR            0xae
+#define X24C01_RADDR            0xaf
+ 
+ 
+/* EEProm (256 * 8) on a Hauppauge card */
+/* and on most BT878s cards to store the sub-system vendor id */
+#define PFC8582_WADDR           0xa0
+#define PFC8582_RADDR		0xa1
+
+#if BKTR_SYSTEM_DEFAULT == BROOKTREE_PAL
+#define DEFAULT_TUNER   PHILIPS_PALI
+#else
+#define DEFAULT_TUNER   PHILIPS_NTSC
+#endif
+
+
+
+
+/*
+ * the data for each type of card
+ *
+ * Note:
+ *   these entried MUST be kept in the order defined by the CARD_XXX defines!
+ */
+static const struct CARDTYPE cards[] = {
+
+	{  CARD_UNKNOWN,			/* the card id */
+	  "Unknown",				/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,					/* the tuner i2c address */
+	   0,					/* dbx unknown */
+	   0,
+	   0,
+	   0,					/* EEProm unknown */
+	   0,					/* EEProm unknown */
+	   { 0, 0, 0, 0, 0 },
+	   0 },					/* GPIO mask */
+
+	{  CARD_MIRO,				/* the card id */
+	  "Pinnacle/Miro TV",			/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,					/* the tuner i2c address */
+	   0,					/* dbx unknown */
+	   0,
+	   0,
+	   0,					/* EEProm unknown */
+	   0,					/* size unknown */
+	   { 0x02, 0x01, 0x00, 0x0a, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+	{  CARD_HAUPPAUGE,			/* the card id */
+	  "Hauppauge WinCast/TV",		/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,					/* the tuner i2c address */
+	   0,					/* dbx is optional */
+	   0,
+	   0,
+	   PFC8582_WADDR,			/* EEProm type */
+	   (u_char)(256 / EEPROMBLOCKSIZE),	/* 256 bytes */
+	   { 0x00, 0x02, 0x01, 0x04, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+	{  CARD_STB,				/* the card id */
+	  "STB TV/PCI",				/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,					/* the tuner i2c address */
+	   0,					/* dbx is optional */
+	   0,
+	   0,
+	   X24C01_WADDR,			/* EEProm type */
+	   (u_char)(128 / EEPROMBLOCKSIZE),	/* 128 bytes */
+	   { 0x00, 0x01, 0x02, 0x02, 1 }, 	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+	{  CARD_INTEL,				/* the card id */
+	  "Intel Smart Video III/VideoLogic Captivator PCI", /* the 'name' */
+	   NULL,				/* the tuner */
+	   0,					/* the tuner i2c address */
+	   0,
+	   0,
+	   0,
+	   0,
+	   0,
+	   { 0, 0, 0, 0, 0 }, 			/* audio MUX values */
+	   0x00 },				/* GPIO mask */
+
+	{  CARD_IMS_TURBO,			/* the card id */
+	  "IMS TV Turbo",			/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,					/* the tuner i2c address */
+	   0,					/* dbx is optional */
+	   0,
+	   0,
+	   PFC8582_WADDR,			/* EEProm type */
+	   (u_char)(256 / EEPROMBLOCKSIZE),	/* 256 bytes */
+	   { 0x01, 0x02, 0x01, 0x00, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+        {  CARD_AVER_MEDIA,			/* the card id */
+          "AVer Media TV/FM",                   /* the 'name' */
+           NULL,                                /* the tuner */
+	   0,					/* the tuner i2c address */
+           0,                                   /* dbx is optional */
+           0,
+	   0,
+           0,                                   /* EEProm type */
+           0,                                   /* EEProm size */
+           { 0x0c, 0x08, 0x04, 0x00, 1 },	/* audio MUX values */
+	   0x1f },				/* GPIO mask */
+
+        {  CARD_OSPREY,				/* the card id */
+          "MMAC Osprey",                   	/* the 'name' */
+           NULL,                                /* the tuner */
+	   0,					/* the tuner i2c address */
+           0,                                   /* dbx is optional */
+	   0,
+           0,
+	   PFC8582_WADDR,			/* EEProm type */
+	   (u_char)(256 / EEPROMBLOCKSIZE),	/* 256 bytes */
+           { 0x00, 0x00, 0x00, 0x00, 0 },	/* audio MUX values */
+	   0 },					/* GPIO mask */
+
+        {  CARD_NEC_PK,                         /* the card id */
+          "NEC PK-UG-X017",                     /* the 'name' */
+           NULL,                                /* the tuner */
+           0,                                   /* the tuner i2c address */
+           0,                                   /* dbx is optional */
+	   0,
+           0,
+           0,                                   /* EEProm type */
+           0,                                   /* EEProm size */
+           { 0x01, 0x02, 0x01, 0x00, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+        {  CARD_IO_GV,                          /* the card id */
+          "I/O DATA GV-BCTV2/PCI",              /* the 'name' */
+           NULL,                                /* the tuner */
+           0,                                   /* the tuner i2c address */
+           0,                                   /* dbx is optional */
+           0,
+	   0,
+           0,                                   /* EEProm type */
+           0,                                   /* EEProm size */
+           { 0x00, 0x00, 0x00, 0x00, 1 },	/* Has special MUX handler */
+	   0x0f },				/* GPIO mask */
+
+        {  CARD_FLYVIDEO,			/* the card id */
+          "FlyVideo",				/* the 'name' */
+           NULL,				/* the tuner */
+           0,					/* the tuner i2c address */
+           0,					/* dbx is optional */
+           0,					/* msp34xx is optional */
+           0,					/* dpl3518a is optional */
+	   0xac,				/* EEProm type */
+	   (u_char)(256 / EEPROMBLOCKSIZE),	/* 256 bytes */
+           { 0x000, 0x800, 0x400, 0x8dff00, 1 },/* audio MUX values */
+	   0x8dff00 },				/* GPIO mask */
+
+	{  CARD_ZOLTRIX,			/* the card id */
+	  "Zoltrix",				/* the 'name' */
+           NULL,				/* the tuner */
+           0,					/* the tuner i2c address */
+           0,					/* dbx is optional */
+           0,					/* msp34xx is optional */
+           0,					/* dpl3518a is optional */
+	   0,					/* EEProm type */
+	   0,					/* EEProm size */
+	   { 0x04, 0x01, 0x00, 0x0a, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+	{  CARD_KISS,				/* the card id */
+	  "KISS TV/FM PCI",			/* the 'name' */
+           NULL,				/* the tuner */
+           0,					/* the tuner i2c address */
+           0,					/* dbx is optional */
+           0,					/* msp34xx is optional */
+           0,					/* dpl3518a is optional */
+	   0,					/* EEProm type */
+	   0,					/* EEProm size */
+	   { 0x0c, 0x00, 0x0b, 0x0b, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+	{  CARD_VIDEO_HIGHWAY_XTREME,		/* the card id */
+	  "Video Highway Xtreme",		/* the 'name' */
+           NULL,				/* the tuner */
+	   0,
+	   0,
+	   0,
+	   0,
+	   0,					/* EEProm type */
+	   0,					/* EEProm size */
+	   { 0x00, 0x02, 0x01, 0x04, 1 },	/* audio MUX values */
+	   0x0f },				/* GPIO mask */
+
+	{  CARD_ASKEY_DYNALINK_MAGIC_TVIEW,	/* the card id */
+	  "Askey/Dynalink Magic TView",		/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,
+	   0,
+	   0,
+	   0,
+	   0,					/* EEProm type */
+	   0,					/* EEProm size */
+	   { 0x400, 0xE00, 0x400, 0xC00, 1 },	/* audio MUX values */
+	   0xE00 },				/* GPIO mask */
+
+	{  CARD_LEADTEK,			/* the card id */
+	  "Leadtek Winfast TV 2000",		/* the 'name' */
+	   NULL,				/* the tuner */
+	   0,
+	   0,
+	   0,
+	   0,
+	   0,					/* EEProm type */
+	   0,					/* EEProm size */
+	   /* Tuner, Extern, Intern, Mute, Enabled */
+	   { 0x621000, 0x621000, 0x621000, 0xE21000, 1 }, /* audio MUX values */
+	   0xfff000 },				/* GPIO mask */
+
+        {  CARD_TERRATVPLUS,                    /* the card id */
+          "TerraTVplus",                        /* the 'name' */
+           NULL,                                /* the tuner */
+	   0,
+	   0,
+	   0,
+	   0,
+	   0,					/* EEProm type */
+	   0,					/* EEProm size */
+           { 0x20000, 0x00000, 0x30000, 0x40000, 1 }, /* audio MUX values*/
+           0x70000 },                           /* GPIO mask */
+
+};
+
+struct bt848_card_sig bt848_card_signature[1]= {
+  /* IMS TURBO TV : card 5 */
+    {  5,9, {00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 00, 02, 00, 00, 00}}
+
+
+};
+
+
+/*
+ * Write to the configuration EEPROM on the card.
+ * This is dangerous and will mess up your card. Therefore it is not
+ * implemented.
+ */
+int      
+writeEEProm( bktr_ptr_t bktr, int offset, int count, u_char *data )
+{
+        return( -1 );
+}
+
+/*
+ * Read the contents of the configuration EEPROM on the card.
+ * (This is not fitted to all makes of card. All Hauppauge cards have them
+ * and so do newer Bt878 based cards.
+ */
+int
+readEEProm( bktr_ptr_t bktr, int offset, int count, u_char *data )
+{
+	int	x;
+	int	addr;
+	int	max;
+	int	byte;
+
+	/* get the address of the EEProm */
+	addr = (int)(bktr->card.eepromAddr & 0xff);
+	if ( addr == 0 )
+		return( -1 );
+
+	max = (int)(bktr->card.eepromSize * EEPROMBLOCKSIZE);
+	if ( (offset + count) > max )
+		return( -1 );
+
+	/* set the start address */
+	if ( i2cWrite( bktr, addr, offset, -1 ) == -1 )
+		return( -1 );
+
+	/* the read cycle */
+	for ( x = 0; x < count; ++x ) {
+		if ( (byte = i2cRead( bktr, (addr | 1) )) == -1 )
+			return( -1 );
+		data[ x ] = byte;
+	}
+
+	return( 0 );
+}
+
+
+#define ABSENT		(-1)
+
+/*
+ * get a signature of the card
+ * read all 128 possible i2c read addresses from 0x01 thru 0xff
+ * build a bit array with a 1 bit for each i2c device that responds
+ *
+ * XXX FIXME: use offset & count args
+ */
+int
+signCard( bktr_ptr_t bktr, int offset, int count, u_char* sig )
+{
+	int	x;
+
+	for ( x = 0; x < 16; ++x )
+		sig[ x ] = 0;
+
+	for ( x = 0; x < count; ++x ) {
+		if ( i2cRead( bktr, (2 * x) + 1 ) != ABSENT ) {
+			sig[ x / 8 ] |= (1 << (x % 8) );
+		}
+	}
+
+	return( 0 );
+}
+
+
+/*
+ * check_for_i2c_devices.
+ * Some BT848 cards have no tuner and no additional i2c devices
+ * eg stereo decoder. These are used for video conferencing or capture from
+ * a video camera. (eg VideoLogic Captivator PCI, Intel SmartCapture card).
+ *
+ * Determine if there are any i2c devices present. There are none present if
+ *  a) reading from all 128 devices returns ABSENT (-1) for each one
+ *     (eg VideoLogic Captivator PCI with BT848)
+ *  b) reading from all 128 devices returns 0 for each one
+ *     (eg VideoLogic Captivator PCI rev. 2F with BT848A)
+ */
+static int check_for_i2c_devices( bktr_ptr_t bktr ){
+  int x, temp_read;
+  int i2c_all_0 = 1;
+  int i2c_all_absent = 1;
+  for ( x = 0; x < 128; ++x ) {
+    temp_read = i2cRead( bktr, (2 * x) + 1 );
+    if (temp_read != 0)      i2c_all_0 = 0;
+    if (temp_read != ABSENT) i2c_all_absent = 0;
+  }
+
+  if ((i2c_all_0) || (i2c_all_absent)) return 0;
+  else return 1;
+}
+
+
+/*
+ * Temic/Philips datasheets say tuners can be at i2c addresses 0xc0, 0xc2,
+ * 0xc4 or 0xc6, settable by links on the tuner.
+ * Determine the actual address used on the TV card by probing read addresses.
+ */
+static int locate_tuner_address( bktr_ptr_t bktr) {
+  if (i2cRead( bktr, 0xc1) != ABSENT) return 0xc0;
+  if (i2cRead( bktr, 0xc3) != ABSENT) return 0xc2;
+  if (i2cRead( bktr, 0xc5) != ABSENT) return 0xc4;
+  if (i2cRead( bktr, 0xc7) != ABSENT) return 0xc6;
+  return -1; /* no tuner found */
+}
+
+ 
+/*
+ * Search for a configuration EEPROM on the i2c bus by looking at i2c addresses
+ * where EEPROMs are usually found.
+ * On some cards, the EEPROM appears in several locations, but all in the
+ * range 0xa0 to 0xae.
+ */
+static int locate_eeprom_address( bktr_ptr_t bktr) {
+  if (i2cRead( bktr, 0xa0) != ABSENT) return 0xa0;
+  if (i2cRead( bktr, 0xac) != ABSENT) return 0xac;
+  if (i2cRead( bktr, 0xae) != ABSENT) return 0xae;
+  return -1; /* no eeprom found */
+}
+
+
+/*
+ * determine the card brand/model
+ * BKTR_OVERRIDE_CARD, BKTR_OVERRIDE_TUNER, BKTR_OVERRIDE_DBX and
+ * BKTR_OVERRIDE_MSP can be used to select a specific device,
+ * regardless of the autodetection and i2c device checks.
+ *
+ * The scheme used for probing cards faces these problems:
+ *  It is impossible to work out which type of tuner is actually fitted,
+ *  (the driver cannot tell if the Tuner is PAL or NTSC, Temic or Philips)
+ *  It is impossible to determine what audio-mux hardware is connected.
+ *  It is impossible to determine if there is extra hardware connected to the
+ *  GPIO pins  (eg radio chips or MSP34xx reset logic)
+ *
+ * However some makes of card (eg Hauppauge) come with a configuration eeprom
+ * which tells us the make of the card. Most eeproms also tell us the
+ * tuner type and other features of the the cards.
+ *
+ * The current probe code works as follows
+ * A) If the card uses a Bt878/879:
+ *   1) Read the sub-system vendor id from the configuration EEPROM.
+ *      Select the required tuner, audio mux arrangement and any other
+ *      onboard features. If this fails, move to step B.
+ * B) If it card uses a Bt848, 848A, 849A or an unknown Bt878/879:
+ *   1) Look for I2C devices. If there are none fitted, it is an Intel or
+ *      VideoLogic cards.
+ *   2) Look for a configuration EEPROM.
+ *   2a) If there is one at I2C address 0xa0 it may be
+ *       a Hauppauge or an Osprey. Check the EEPROM contents to determine which
+ *       one it is. For Hauppauge, select the tuner type and audio hardware.
+ *   2b) If there is an EEPROM at I2C address 0xa8 it will be an STB card.
+ *       We still have to guess on the tuner type.
+ *              
+ * C) If we do not know the card type from (A) or (B), guess at the tuner
+ *    type based on the I2C address of the tuner.
+ *
+ * D) After determining the Tuner Type, we probe the i2c bus for other
+ *    devices at known locations, eg IR-Remote Control, MSP34xx and TDA
+ *    stereo chips.
+ */
+
+
+/*
+ * These are the sub-system vendor ID codes stored in the
+ * configuration EEPROM used on Bt878/879 cards. They should match the
+ * number assigned to the company by the PCI Special Interest Group
+ */
+#ifndef __NetBSD__
+#define PCI_VENDOR_HAUPPAUGE	0x0070
+#define PCI_VENDOR_AVERMEDIA	0x1461
+#define PCI_VENDOR_STB		0x10B4
+#define PCI_VENDOR_ASKEY	0x144F
+#endif
+/* Following not confirmed with http://members.hyperlink.net.au/~chart,
+   so not added to NetBSD's pcidevs */
+#define PCI_VENDOR_LEADTEK_ALT	0x6606
+#define PCI_VENDOR_FLYVIDEO	0x1851
+#define PCI_VENDOR_FLYVIDEO_2	0x1852
+#define PCI_VENDOR_PINNACLE_ALT	0xBD11
+
+
+void
+probeCard( bktr_ptr_t bktr, int verbose, int unit )
+{
+	int		card, i,j, card_found;
+	int		status;
+	u_char 		probe_signature[128], *probe_temp;
+        int   		any_i2c_devices;
+	u_char 		eeprom[256];
+	int 		tuner_i2c_address = -1;
+	int 		eeprom_i2c_address = -1;
+
+	/* Select all GPIO bits as inputs */
+	OUTL(bktr, BKTR_GPIO_OUT_EN, 0);
+	if (bootverbose)
+	    printf("%s: GPIO is 0x%08x\n", bktr_name(bktr),
+		   INL(bktr, BKTR_GPIO_DATA)); 
+
+#ifdef HAUPPAUGE_MSP_RESET
+	/* Reset the MSP34xx audio chip. This resolves bootup card
+	 * detection problems with old Bt848 based Hauppauge cards with
+	 * MSP34xx stereo audio chips. This must be user enabled because
+	 * at this point the probe function does not know the card type. */
+        OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | (1<<5));
+        OUTL(bktr, BKTR_GPIO_DATA, INL(bktr, BKTR_GPIO_DATA) | (1<<5));  /* write '1' */
+        DELAY(2500); /* wait 2.5ms */
+        OUTL(bktr, BKTR_GPIO_DATA, INL(bktr, BKTR_GPIO_DATA) & ~(1<<5)); /* write '0' */
+        DELAY(2500); /* wait 2.5ms */
+        OUTL(bktr, BKTR_GPIO_DATA, INL(bktr, BKTR_GPIO_DATA) | (1<<5));  /* write '1' */
+        DELAY(2500); /* wait 2.5ms */
+#endif
+
+	/* Check for the presence of i2c devices */
+        any_i2c_devices = check_for_i2c_devices( bktr );
+
+
+	/* Check for a user specified override on the card selection */
+#if defined( BKTR_OVERRIDE_CARD )
+	bktr->card = cards[ (card = BKTR_OVERRIDE_CARD) ];
+	goto checkEEPROM;
+#endif
+	if (bktr->bt848_card != -1 ) {
+	  bktr->card = cards[ (card = bktr->bt848_card) ];
+	  goto checkEEPROM;
+	}
+
+
+	/* No override, so try and determine the make of the card */
+
+        /* On BT878/879 cards, read the sub-system vendor id */
+	/* This identifies the manufacturer of the card and the model */
+	/* In theory this can be read from PCI registers but this does not */
+	/* appear to work on the FlyVideo 98. Hauppauge also warned that */
+	/* the PCI registers are sometimes not loaded correctly. */
+	/* Therefore, I will read the sub-system vendor ID from the EEPROM */
+	/* (just like the Bt878 does during power up initialisation) */
+
+        if ((bktr->id==BROOKTREE_878) || (bktr->id==BROOKTREE_879)) {
+	    /* Try and locate the EEPROM */
+	    eeprom_i2c_address = locate_eeprom_address( bktr );
+	    if (eeprom_i2c_address != -1) {
+
+                unsigned int subsystem_vendor_id; /* vendors PCI-SIG ID */
+                unsigned int subsystem_id;        /* board model number */
+		unsigned int byte_252, byte_253, byte_254, byte_255;
+
+		bktr->card = cards[ (card = CARD_UNKNOWN) ];
+		bktr->card.eepromAddr = eeprom_i2c_address;
+		bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+
+	        readEEProm(bktr, 0, 256, (u_char *) &eeprom );
+                byte_252 = (unsigned int)eeprom[252];
+                byte_253 = (unsigned int)eeprom[253];
+                byte_254 = (unsigned int)eeprom[254];
+                byte_255 = (unsigned int)eeprom[255];
+                
+                subsystem_id        = (byte_252 << 8) | byte_253;
+                subsystem_vendor_id = (byte_254 << 8) | byte_255;
+
+	        if ( bootverbose ) 
+	            printf("%s: subsystem 0x%04x 0x%04x\n", bktr_name(bktr),
+			   subsystem_vendor_id, subsystem_id);
+
+                if (subsystem_vendor_id == PCI_VENDOR_AVERMEDIA) {
+                    bktr->card = cards[ (card = CARD_AVER_MEDIA) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+                if (subsystem_vendor_id == PCI_VENDOR_HAUPPAUGE) {
+                    bktr->card = cards[ (card = CARD_HAUPPAUGE) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+                if ((subsystem_vendor_id == PCI_VENDOR_FLYVIDEO)
+                 || (subsystem_vendor_id == PCI_VENDOR_FLYVIDEO_2) ) {
+                    bktr->card = cards[ (card = CARD_FLYVIDEO) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+                if (subsystem_vendor_id == PCI_VENDOR_STB) {
+                    bktr->card = cards[ (card = CARD_STB) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+                if (subsystem_vendor_id == PCI_VENDOR_ASKEY) {
+                    bktr->card = cards[ (card = CARD_ASKEY_DYNALINK_MAGIC_TVIEW) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+                if (subsystem_vendor_id == PCI_VENDOR_LEADTEK_ALT) {
+                    bktr->card = cards[ (card = CARD_LEADTEK) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+		if (subsystem_vendor_id == PCI_VENDOR_PINNACLE_ALT) {
+                    bktr->card = cards[ (card = CARD_MIRO) ];
+		    bktr->card.eepromAddr = eeprom_i2c_address;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+                }
+
+                /* Vendor is unknown. We will use the standard probe code */
+		/* which may not give best results */
+                printf("%s: Warning - card vendor 0x%04x (model 0x%04x) unknown.\n",
+		       bktr_name(bktr), subsystem_vendor_id, subsystem_id);
+            }
+	    else
+	    {
+                printf("%s: Card has no configuration EEPROM. Cannot determine card make.\n",
+		       bktr_name(bktr));
+	    }
+	} /* end of bt878/bt879 card detection code */
+
+	/* If we get to this point, we must have a Bt848/848A/849A card */
+	/* or a Bt878/879 with an unknown subsystem vendor id */
+        /* Try and determine the make of card by clever i2c probing */
+
+   	/* Check for i2c devices. If none, move on */
+	if (!any_i2c_devices) {
+		bktr->card = cards[ (card = CARD_INTEL) ];
+		bktr->card.eepromAddr = 0;
+		bktr->card.eepromSize = 0;
+		goto checkTuner;
+	}
+
+        /* Look for Hauppauge, STB and Osprey cards by the presence */
+	/* of an EEPROM */
+        /* Note: Bt878 based cards also use EEPROMs so we can only do this */
+        /* test on BT848/848A and 849A based cards. */
+	if ((bktr->id==BROOKTREE_848)  ||
+	    (bktr->id==BROOKTREE_848A) ||
+	    (bktr->id==BROOKTREE_849A)) {
+
+            /* At i2c address 0xa0, look for Hauppauge and Osprey cards */
+            if ( (status = i2cRead( bktr, PFC8582_RADDR )) != ABSENT ) {
+
+		    /* Read the eeprom contents */
+		    bktr->card = cards[ (card = CARD_UNKNOWN) ];
+		    bktr->card.eepromAddr = PFC8582_WADDR;
+		    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+	            readEEProm(bktr, 0, 128, (u_char *) &eeprom );
+
+		    /* For Hauppauge, check the EEPROM begins with 0x84 */
+		    if (eeprom[0] == 0x84) {
+                            bktr->card = cards[ (card = CARD_HAUPPAUGE) ];
+			    bktr->card.eepromAddr = PFC8582_WADDR;
+			    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                            goto checkTuner;
+		    }
+
+		    /* For Osprey, check the EEPROM begins with "MMAC" */
+		    if (  (eeprom[0] == 'M') &&(eeprom[1] == 'M')
+			&&(eeprom[2] == 'A') &&(eeprom[3] == 'C')) {
+                            bktr->card = cards[ (card = CARD_OSPREY) ];
+			    bktr->card.eepromAddr = PFC8582_WADDR;
+			    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+                            goto checkTuner;
+		    }
+		    printf("%s: Warning: Unknown card type. EEPROM data not recognised\n",
+			   bktr_name(bktr));
+		    printf("%s: %x %x %x %x\n", bktr_name(bktr),
+			   eeprom[0],eeprom[1],eeprom[2],eeprom[3]);
+            }
+
+            /* look for an STB card */
+            if ( (status = i2cRead( bktr, X24C01_RADDR )) != ABSENT ) {
+                    bktr->card = cards[ (card = CARD_STB) ];
+		    bktr->card.eepromAddr = X24C01_WADDR;
+		    bktr->card.eepromSize = (u_char)(128 / EEPROMBLOCKSIZE);
+                    goto checkTuner;
+            }
+
+	}
+
+	signCard( bktr, 1, 128, (u_char *)  &probe_signature );
+
+	if (bootverbose) {
+	  printf("%s: card signature: ", bktr_name(bktr));
+	  for (j = 0; j < Bt848_MAX_SIGN; j++) {
+	    printf(" %02x ", probe_signature[j]);
+	  }
+	  printf("\n\n");
+	}
+	for (i = 0;
+	     i < (sizeof bt848_card_signature)/ sizeof (struct bt848_card_sig);
+	     i++ ) {
+
+	  card_found = 1;
+	  probe_temp = (u_char *) &bt848_card_signature[i].signature;
+
+	  for (j = 0; j < Bt848_MAX_SIGN; j++) {
+	    if ((probe_temp[j] & 0xf) != (probe_signature[j] & 0xf)) {
+	      card_found = 0;
+	      break;
+	    }
+
+	  }
+	  if (card_found) {
+	    bktr->card = cards[ card = bt848_card_signature[i].card];
+	    eeprom_i2c_address = locate_eeprom_address( bktr );
+	    if (eeprom_i2c_address != -1) {
+		bktr->card.eepromAddr = eeprom_i2c_address;
+		bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+	    } else {
+		bktr->card.eepromAddr = 0;
+		bktr->card.eepromSize = 0;
+	    }
+	    tuner_i2c_address = locate_tuner_address( bktr );   
+	    select_tuner( bktr, bt848_card_signature[i].tuner );
+	    goto checkDBX;
+	  }
+	}
+
+	/* We do not know the card type. Default to Miro */
+	bktr->card = cards[ (card = CARD_MIRO) ];
+
+
+checkEEPROM:
+	/* look for a configuration eeprom */
+	eeprom_i2c_address = locate_eeprom_address( bktr );
+	if (eeprom_i2c_address != -1) {
+	    bktr->card.eepromAddr = eeprom_i2c_address;
+	    bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE);
+	} else {
+	    bktr->card.eepromAddr = 0;
+	    bktr->card.eepromSize = 0;
+	}
+
+
+checkTuner:
+
+	/* look for a tuner */
+	tuner_i2c_address = locate_tuner_address( bktr );
+	if ( tuner_i2c_address == -1 ) {
+		select_tuner( bktr, NO_TUNER );
+		goto checkDBX;
+	}
+
+#if defined( BKTR_OVERRIDE_TUNER )
+	select_tuner( bktr, BKTR_OVERRIDE_TUNER );
+	goto checkDBX;
+#endif
+	if (bktr->bt848_tuner != -1 ) {
+	  select_tuner( bktr, bktr->bt848_tuner & 0xff );
+	  goto checkDBX;
+	}
+
+	/* Check for i2c devices */
+	if (!any_i2c_devices) {
+		select_tuner( bktr, NO_TUNER );
+		goto checkDBX;
+	}
+
+	/* differentiate type of tuner */
+
+	switch (card) {
+	case CARD_MIRO:
+	    switch (((INL(bktr, BKTR_GPIO_DATA) >> 10)-1)&7) {
+	    case 0: select_tuner( bktr, TEMIC_PAL ); break;
+	    case 1: select_tuner( bktr, PHILIPS_PAL ); break;
+	    case 2: select_tuner( bktr, PHILIPS_NTSC ); break;
+	    case 3: select_tuner( bktr, PHILIPS_SECAM ); break;
+	    case 4: select_tuner( bktr, NO_TUNER ); break;
+	    case 5: select_tuner( bktr, PHILIPS_PALI ); break;
+	    case 6: select_tuner( bktr, TEMIC_NTSC ); break;
+	    case 7: select_tuner( bktr, TEMIC_PALI ); break;
+	    }
+	    goto checkDBX;
+	    break;
+
+	case CARD_HAUPPAUGE:
+	    /* Hauppauge kindly supplied the following Tuner Table */
+	    /* FIXME: I think the tuners the driver selects for types */
+	    /* 0x08 and 0x15 may be incorrect but no one has complained. */
+	    /* Old Temic tuners had their own API, but newer Temic tuners */
+	    /* have the same API as Philips tuners */
+	    /*
+  ID  Tuner Model           Format			We select Format
+ 0x00 NONE               
+ 0x01 EXTERNAL             
+ 0x02 OTHER                
+ 0x03 Philips FI1216        BG 
+ 0x04 Philips FI1216MF      BGLL'			PHILIPS_SECAM
+ 0x05 Philips FI1236        MN 				PHILIPS_NTSC
+ 0x06 Philips FI1246        I 				PHILIPS_PALI
+ 0x07 Philips FI1256        DK 
+ 0x08 Philips FI1216 MK2    BG 				PHILIPS_PALI
+ 0x09 Philips FI1216MF MK2  BGLL' 			PHILIPS_SECAM
+ 0x0a Philips FI1236 MK2    MN 				PHILIPS_NTSC
+ 0x0b Philips FI1246 MK2    I 				PHILIPS_PALI
+ 0x0c Philips FI1256 MK2    DK 
+ 0x0d Temic 4032FY5         NTSC			TEMIC_NTSC
+ 0x0e Temic 4002FH5         BG				TEMIC_PAL
+ 0x0f Temic 4062FY5         I 				TEMIC_PALI
+ 0x10 Philips FR1216 MK2    BG 
+ 0x11 Philips FR1216MF MK2  BGLL' 			PHILIPS_FR1236_SECAM
+ 0x12 Philips FR1236 MK2    MN 				PHILIPS_FR1236_NTSC
+ 0x13 Philips FR1246 MK2    I 
+ 0x14 Philips FR1256 MK2    DK 
+ 0x15 Philips FM1216        BG 				PHILIPS_FR1216_PAL
+ 0x16 Philips FM1216MF      BGLL' 			PHILIPS_FR1236_SECAM
+ 0x17 Philips FM1236        MN 				PHILIPS_FR1236_NTSC
+ 0x18 Philips FM1246        I 
+ 0x19 Philips FM1256        DK 
+ 0x1a Temic 4036FY5         MN (FI1236 MK2 clone)	PHILIPS_NTSC
+ 0x1b Samsung TCPN9082D     MN 
+ 0x1c Samsung TCPM9092P     Pal BG/I/DK 
+ 0x1d Temic 4006FH5         BG				PHILIPS_PALI
+ 0x1e Samsung TCPN9085D     MN/Radio 
+ 0x1f Samsung TCPB9085P     Pal BG/I/DK / Radio 
+ 0x20 Samsung TCPL9091P     Pal BG & Secam L/L' 
+ 0x21 Temic 4039FY5         NTSC Radio
+ 0x22 Philips FQ1216ME      Pal BGIDK & Secam L/L' 
+ 0x23 Temic 4066FY5         Pal I (FI1246 MK2 clone)	PHILIPS_PALI
+ 0x24 Philips TD1536        MN/ATSCDigital
+ 0x25 Philips TD1536D       MN/ATSCDigital DUAL INPUT
+ 0x26 Philips FMR1236       M/N FM(no demod)
+ 0x27 Philips FI1256MP      B/G, D/K
+ 0x28 Samsung TCPQ9091P     BG/I/DK, L/L'
+ 0x29 Temic 4006FN5         BG/I/DK
+ 0x2a Temic 4009FR5         BG FM			PHILIPS_FR1216_PAL
+ 0x2b Temic 4046FM5         B/G, I, D/K, L/L'
+ 0x2c Temic 4009FN5         B/G, I, D/K, FM (no demod)
+ 0x2d Philips TD1536D_FH_44 MN/ATSCDigital DUAL INPUT
+	    */
+
+
+	    /* Determine the model number from the eeprom */
+	    if (bktr->card.eepromAddr != 0) {
+	        /* eeprom data block structure */
+	        unsigned char *block_1, *block_2, *block_3, *block_4;
+	        int block_1_data_size,  block_2_data_size, block_3_data_size;
+	        int block_1_total_size, block_2_total_size, block_3_total_size;
+		int block_4_header_size;
+
+		unsigned int model,revision;
+		unsigned char tuner_code;
+		unsigned char no_audio_mux;
+
+		readEEProm(bktr, 0, 128, (u_char *) &eeprom );
+
+	        /* LOCATE THE EEPROM DATA BLOCKS */
+	        block_1 = &eeprom[0];
+	        block_1_data_size = (block_1[2] << 8 | block_1[1]);
+	        block_1_total_size = block_1_data_size + 3; /* Header bytes */   
+    
+	        block_2 = &eeprom[block_1_total_size];
+	        block_2_data_size = (block_2[2] << 8 | block_2[1]);
+	        block_2_total_size = block_2_data_size + 3; /* Header bytes */
+    
+	        block_3 = &eeprom[block_1_total_size + block_2_total_size];
+	        block_3_data_size = (block_3[0] &0x07);
+	        block_3_total_size = block_3_data_size + 1; /* Header size */
+
+	        block_4 = &eeprom[block_1_total_size +block_2_total_size +block_3_total_size];
+	        block_4_header_size = 1;
+
+		model    = (block_1[12] << 8  | block_1[11]);
+		revision = (block_1[15] << 16 | block_1[14] << 8 | block_1[13]);
+
+		tuner_code = block_1[9];
+
+		no_audio_mux = ((block_3[3] >> 7) &0x01);
+
+		if (no_audio_mux) bktr->audio_mux_present = 0;
+               
+		if (verbose)
+		    printf("%s: Hauppauge Model %d %c%c%c%c\n",
+			   bktr_name(bktr),
+			   model,
+			   ((revision >> 18) & 0x3f) + 32,
+			   ((revision >> 12) & 0x3f) + 32,
+			   ((revision >>  6) & 0x3f) + 32,
+			   ((revision >>  0) & 0x3f) + 32 );
+
+	        /* Determine the tuner type from the eeprom */
+
+		switch (tuner_code) {
+
+		  case 0x5:
+                  case 0x0a:
+                  case 0x1a:
+		    select_tuner( bktr, PHILIPS_NTSC );
+		    goto checkDBX;
+
+		  case 0x4:
+                  case 0x9:
+		    select_tuner( bktr, PHILIPS_SECAM );
+		    goto checkDBX;
+
+                  case 0x11:
+	          case 0x16:
+		    select_tuner( bktr, PHILIPS_FR1236_SECAM );
+		    goto checkDBX;
+
+                  case 0x12:
+	          case 0x17:
+		    select_tuner( bktr, PHILIPS_FR1236_NTSC );
+		    goto checkDBX;
+
+		  case 0x6:
+	          case 0x8:
+	          case 0xb:
+	          case 0x1d:
+	          case 0x23:
+		    select_tuner( bktr, PHILIPS_PALI );
+		    goto checkDBX;
+
+	          case 0xd:
+		    select_tuner( bktr, TEMIC_NTSC );
+		    goto checkDBX;
+
+                  case 0xe:
+		    select_tuner( bktr, TEMIC_PAL );
+		    goto checkDBX;
+
+	          case 0xf:
+		    select_tuner( bktr, TEMIC_PALI );
+		    goto checkDBX;
+
+                  case 0x15:
+		    select_tuner( bktr, PHILIPS_FR1216_PAL );
+		    goto checkDBX;
+
+                  case 0x2a:
+		    bktr->msp_use_mono_source = 1;
+		    select_tuner( bktr, PHILIPS_FR1216_PAL );
+		    goto checkDBX;
+
+	          default :
+		    printf("%s: Warning - Unknown Hauppauge Tuner 0x%x\n",
+			   bktr_name(bktr), tuner_code);
+		}
+	    }
+	    break;
+
+
+	case CARD_AVER_MEDIA:
+	    /* AVerMedia kindly supplied some details of their EEPROM contents
+	     * which allow us to auto select the Tuner Type.
+	     * Only the newer AVerMedia cards actually have an EEPROM.
+	     */
+	    if (bktr->card.eepromAddr != 0) {
+
+		u_char tuner_make;   /* Eg Philips, Temic */
+		u_char tuner_tv_fm;  /* TV or TV with FM Radio */
+		u_char tuner_format; /* Eg NTSC, PAL, SECAM */
+		int    tuner;
+
+		int tuner_0_table[] = {
+			PHILIPS_NTSC,  PHILIPS_PAL,
+			PHILIPS_PAL,   PHILIPS_PAL,
+			PHILIPS_PAL,   PHILIPS_PAL,
+			PHILIPS_SECAM, PHILIPS_SECAM,
+			PHILIPS_SECAM, PHILIPS_PAL};
+
+		int tuner_0_fm_table[] = {
+			PHILIPS_FR1236_NTSC,  PHILIPS_FR1216_PAL,
+			PHILIPS_FR1216_PAL,   PHILIPS_FR1216_PAL,
+			PHILIPS_FR1216_PAL,   PHILIPS_FR1216_PAL,
+			PHILIPS_FR1236_SECAM, PHILIPS_FR1236_SECAM,
+			PHILIPS_FR1236_SECAM, PHILIPS_FR1216_PAL};
+
+		int tuner_1_table[] = {
+			TEMIC_NTSC,  TEMIC_PAL,   TEMIC_PAL,
+			TEMIC_PAL,   TEMIC_PAL,   TEMIC_PAL,
+			TEMIC_SECAM, TEMIC_SECAM, TEMIC_SECAM,
+			TEMIC_PAL};
+
+
+		/* Extract information from the EEPROM data */
+	    	readEEProm(bktr, 0, 128, (u_char *) &eeprom );
+
+		tuner_make   = (eeprom[0x41] & 0x7);
+		tuner_tv_fm  = (eeprom[0x41] & 0x18) >> 3;
+		tuner_format = (eeprom[0x42] & 0xf0) >> 4;
+
+		/* Treat tuner make 0 (Philips) and make 2 (LG) the same */
+		if ( ((tuner_make == 0) || (tuner_make == 2))
+		    && (tuner_format <= 9) && (tuner_tv_fm == 0) ) {
+			tuner = tuner_0_table[tuner_format];
+			select_tuner( bktr, tuner );
+			goto checkDBX;
+		}
+
+		if ( ((tuner_make == 0) || (tuner_make == 2))
+		    && (tuner_format <= 9) && (tuner_tv_fm == 1) ) {
+			tuner = tuner_0_fm_table[tuner_format];
+			select_tuner( bktr, tuner );
+			goto checkDBX;
+		}
+
+		if ( (tuner_make == 1) && (tuner_format <= 9) ) {
+			tuner = tuner_1_table[tuner_format];
+			select_tuner( bktr, tuner );
+			goto checkDBX;
+		}
+
+	    	printf("%s: Warning - Unknown AVerMedia Tuner Make %d Format %d\n",
+			bktr_name(bktr), tuner_make, tuner_format);
+	    }
+	    break;
+
+	case CARD_LEADTEK:
+#if BKTR_SYSTEM_DEFAULT == BROOKTREE_PAL
+	    select_tuner( bktr, PHILIPS_FR1216_PAL );
+#else
+	    select_tuner( bktr, PHILIPS_FR1236_NTSC );
+#endif
+            goto checkDBX;
+	    break;
+
+	} /* end switch(card) */
+
+
+        /* At this point, a goto checkDBX has not occured */
+        /* We have not been able to select a Tuner */
+        /* Some cards make use of the tuner address to */
+        /* identify the make/model of tuner */
+
+        /* At address 0xc0/0xc1 we often find a TEMIC NTSC */
+        if ( i2cRead( bktr, 0xc1 ) != ABSENT ) {
+	    select_tuner( bktr, TEMIC_NTSC );
+            goto checkDBX;
+        }
+  
+        /* At address 0xc6/0xc7 we often find a PHILIPS NTSC Tuner */
+        if ( i2cRead( bktr, 0xc7 ) != ABSENT ) {
+	    select_tuner( bktr, PHILIPS_NTSC );
+            goto checkDBX;
+        }
+
+        /* Address 0xc2/0xc3 is default (or common address) for several */
+	/* tuners and we cannot tell which is which. */
+	/* And for all other tuner i2c addresses, select the default */
+	select_tuner( bktr, DEFAULT_TUNER );
+
+
+checkDBX:
+#if defined( BKTR_OVERRIDE_DBX )
+	bktr->card.dbx = BKTR_OVERRIDE_DBX;
+	goto checkMSP;
+#endif
+   /* Check for i2c devices */
+	if (!any_i2c_devices) {
+		goto checkMSP;
+	}
+
+	/* probe for BTSC (dbx) chip */
+	if ( i2cRead( bktr, TDA9850_RADDR ) != ABSENT )
+		bktr->card.dbx = 1;
+
+checkMSP:
+	/* If this is a Hauppauge Bt878 card, we need to enable the
+	 * MSP 34xx audio chip. 
+	 * If this is a Hauppauge Bt848 card, reset the MSP device.
+	 * The MSP reset line is wired to GPIO pin 5. On Bt878 cards a pulldown
+	 * resistor holds the device in reset until we set GPIO pin 5.
+         */
+
+	/* Optionally skip the MSP reset. This is handy if you initialise the
+	 * MSP audio in another operating system (eg Windows) first and then
+	 * do a soft reboot.
+	 */
+
+#ifndef BKTR_NO_MSP_RESET
+	if (card == CARD_HAUPPAUGE) {
+            OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | (1<<5));
+            OUTL(bktr, BKTR_GPIO_DATA, INL(bktr, BKTR_GPIO_DATA) | (1<<5));  /* write '1' */
+            DELAY(2500); /* wait 2.5ms */
+            OUTL(bktr, BKTR_GPIO_DATA, INL(bktr, BKTR_GPIO_DATA) & ~(1<<5)); /* write '0' */
+            DELAY(2500); /* wait 2.5ms */
+            OUTL(bktr, BKTR_GPIO_DATA, INL(bktr, BKTR_GPIO_DATA) | (1<<5));  /* write '1' */
+            DELAY(2500); /* wait 2.5ms */
+        }
+#endif
+
+#if defined( BKTR_OVERRIDE_MSP )
+	bktr->card.msp3400c = BKTR_OVERRIDE_MSP;
+	goto checkMSPEnd;
+#endif
+
+	/* Check for i2c devices */
+	if (!any_i2c_devices) {
+		goto checkMSPEnd;
+	}
+
+	if ( i2cRead( bktr, MSP3400C_RADDR ) != ABSENT ) {
+		bktr->card.msp3400c = 1;
+	}
+
+checkMSPEnd:
+
+	if (bktr->card.msp3400c) {
+		bktr->msp_addr = MSP3400C_WADDR;
+		msp_read_id( bktr );
+		printf("%s: Detected a MSP%s at 0x%x\n", bktr_name(bktr),
+		       bktr->msp_version_string,
+		       bktr->msp_addr);
+
+	}
+
+/* Check for Dolby Surround Sound DPL3518A sound chip */
+	if ( i2cRead( bktr, DPL3518A_RADDR ) != ABSENT ) {
+		bktr->card.dpl3518a = 1;
+	}
+
+	if (bktr->card.dpl3518a) {
+		bktr->dpl_addr = DPL3518A_WADDR;
+		dpl_read_id( bktr );
+		printf("%s: Detected a DPL%s at 0x%x\n", bktr_name(bktr),
+		       bktr->dpl_version_string,
+		       bktr->dpl_addr);
+	}
+
+/* Start of Check Remote */
+        /* Check for the Hauppauge IR Remote Control */
+        /* If there is an external unit, the internal will be ignored */
+
+        bktr->remote_control = 0; /* initial value */
+
+        if (any_i2c_devices) {
+            if (i2cRead( bktr, HAUP_REMOTE_EXT_RADDR ) != ABSENT )
+                {
+                bktr->remote_control      = 1;
+                bktr->remote_control_addr = HAUP_REMOTE_EXT_RADDR;
+                }
+            else if (i2cRead( bktr, HAUP_REMOTE_INT_RADDR ) != ABSENT )
+                {
+                bktr->remote_control      = 1;
+                bktr->remote_control_addr = HAUP_REMOTE_INT_RADDR;
+                }
+
+        }
+        /* If a remote control is found, poll it 5 times to turn off the LED */
+        if (bktr->remote_control) {
+                int i;
+                for (i=0; i<5; i++)
+                        i2cRead( bktr, bktr->remote_control_addr );
+        }
+/* End of Check Remote */
+
+#if defined( BKTR_USE_PLL )
+	bktr->xtal_pll_mode = BT848_USE_PLL;
+	goto checkPLLEnd;
+#endif
+	/* Default is to use XTALS and not PLL mode */
+	bktr->xtal_pll_mode = BT848_USE_XTALS;
+
+	/* Enable PLL mode for OSPREY users */
+	if (card == CARD_OSPREY)
+		bktr->xtal_pll_mode = BT848_USE_PLL;
+
+	/* Enable PLL mode for Video Highway Xtreme users */
+	if (card == CARD_VIDEO_HIGHWAY_XTREME)
+		bktr->xtal_pll_mode = BT848_USE_PLL;
+
+
+	/* Most (perhaps all) Bt878 cards need to be switched to PLL mode */
+	/* as they only fit the NTSC crystal to their cards */
+	/* Default to enabling PLL mode for all Bt878/879 cards */
+
+	if ((bktr->id==BROOKTREE_878 || bktr->id==BROOKTREE_879) )
+		bktr->xtal_pll_mode = BT848_USE_PLL;
+
+
+#if defined( BKTR_USE_PLL )
+checkPLLEnd:
+#endif
+
+
+	bktr->card.tuner_pllAddr = tuner_i2c_address;
+
+	if ( verbose ) {
+		printf( "%s: %s", bktr_name(bktr), bktr->card.name );
+		if ( bktr->card.tuner )
+			printf( ", %s tuner", bktr->card.tuner->name );
+		if ( bktr->card.dbx )
+			printf( ", dbx stereo" );
+		if ( bktr->card.msp3400c )
+			printf( ", msp3400c stereo" );
+		if ( bktr->card.dpl3518a )
+			printf( ", dpl3518a dolby" );
+                if ( bktr->remote_control )
+                        printf( ", remote control" );
+		printf( ".\n" );
+	}
+}
+
+#undef ABSENT
diff --git a/sys/dev/pci/bktr/bktr_card.h b/sys/dev/pci/bktr/bktr_card.h
new file mode 100644
index 00000000000..5d948440c7d
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_card.h
@@ -0,0 +1,88 @@
+/*	$OpenBSD: bktr_card.h,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_card.h,v 1.4 2000/06/26 09:41:31 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_card : This deals with identifying TV cards.
+ *               trying to find the card make and model of card.
+ *               trying to find the type of tuner fitted.
+ *               reading the configuration EEPROM.
+ *               locating i2c devices.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * If probeCard() fails to detect the correct card on boot you can
+ * override it by setting adding the following option to your kernel config
+ *  options BKTR_OVERRIDE_CARD  <card type>
+ *  eg options BKTR_OVERRIDE CARD=1
+ *
+ * or using the sysclt  hw.bt848.card
+ *  eg sysctl -w hw.bt848.card=1
+ *
+ * where <card type> is one of the following card defines.
+ */
+ 
+#define CARD_UNKNOWN		0
+#define CARD_MIRO		1
+#define CARD_HAUPPAUGE		2
+#define CARD_STB		3
+#define CARD_INTEL		4   /* Also for VideoLogic Captivator PCI */
+#define CARD_IMS_TURBO		5
+#define CARD_AVER_MEDIA		6
+#define CARD_OSPREY		7
+#define CARD_NEC_PK		8
+#define CARD_IO_GV		9
+#define CARD_FLYVIDEO		10
+#define CARD_ZOLTRIX		11
+#define CARD_KISS		12
+#define CARD_VIDEO_HIGHWAY_XTREME	13
+#define CARD_ASKEY_DYNALINK_MAGIC_TVIEW	14
+#define CARD_LEADTEK		15
+#define CARD_TERRATVPLUS	16
+#define Bt848_MAX_CARD		17
+
+
+int	signCard( bktr_ptr_t bktr, int offset, int count, u_char* sig );
+void	probeCard( bktr_ptr_t bktr, int verbose, int unit);
+
+int	writeEEProm( bktr_ptr_t bktr, int offset, int count, u_char *data );
+int	readEEProm( bktr_ptr_t bktr, int offset, int count, u_char *data );
+
diff --git a/sys/dev/pci/bktr/bktr_core.c b/sys/dev/pci/bktr/bktr_core.c
new file mode 100644
index 00000000000..16f56150d44
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_core.c
@@ -0,0 +1,4264 @@
+/*	$OpenBSD: bktr_core.c,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_core.c,v 1.114 2000/10/31 13:09:56 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_core : This deals with the Bt848/849/878/879 PCI Frame Grabber,
+ *               Handles all the open, close, ioctl and read userland calls.
+ *               Sets the Bt848 registers and generates RISC pograms.
+ *               Controls the i2c bus and GPIO interface.
+ *               Contains the interface to the kernel.
+ *               (eg probe/attach and open/close/ioctl)
+ *
+ */
+
+ /*
+   The Brooktree BT848 Driver driver is based upon Mark Tinguely and
+   Jim Lowe's driver for the Matrox Meteor PCI card . The 
+   Philips SAA 7116 and SAA 7196 are very different chipsets than
+   the BT848.
+
+   The original copyright notice by Mark and Jim is included mostly
+   to honor their fantastic work in the Matrox Meteor driver!
+
+ */
+
+/*
+ * 1. Redistributions of source code must retain the 
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products 
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+
+/*
+ * 1. Redistributions of source code must retain the 
+ * Copyright (c) 1995 Mark Tinguely and Jim Lowe
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Mark Tinguely and Jim Lowe
+ * 4. The name of the author may not be used to endorse or promote products 
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __OpenBSD__
+#include "opt_bktr.h"		/* Include any kernel config options */
+#endif
+
+#ifdef __FreeBSD__
+#include "bktr.h"
+#endif /* __FreeBSD__ */
+
+#if (                                                            \
+       (defined(__FreeBSD__) && (NBKTR > 0))                     \
+    || (defined(__bsdi__))                                       \
+    || (defined(__OpenBSD__))                                    \
+    || (defined(__NetBSD__))                                     \
+    )
+
+
+/*******************/
+/* *** FreeBSD *** */
+/*******************/
+#ifdef __FreeBSD__
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/signalvar.h>
+#include <sys/vnode.h>
+
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/pmap.h>
+#include <vm/vm_extern.h>
+
+#if (__FreeBSD_version >=400000) || (NSMBUS > 0)
+#include <sys/bus.h>		/* used by smbus and newbus */
+#endif
+
+#if (__FreeBSD_version < 500000)
+#include <machine/clock.h>              /* for DELAY */
+#endif
+
+#include <pci/pcivar.h>
+
+#if (__FreeBSD_version >=300000)
+#include <machine/bus_memio.h>	/* for bus space */
+#include <machine/bus.h>
+#include <sys/bus.h>
+#endif
+
+#include <machine/ioctl_meteor.h>
+#include <machine/ioctl_bt848.h>	/* extensions to ioctl_meteor.h */
+#include <dev/bktr/bktr_reg.h>
+#include <dev/bktr/bktr_tuner.h>
+#include <dev/bktr/bktr_card.h>
+#include <dev/bktr/bktr_audio.h>
+#include <dev/bktr/bktr_os.h>
+#include <dev/bktr/bktr_core.h>
+#if defined(BKTR_FREEBSD_MODULE)
+#include <dev/bktr/bktr_mem.h>
+#endif
+
+#if defined(BKTR_USE_FREEBSD_SMBUS)
+#include <dev/bktr/bktr_i2c.h>
+#include <dev/smbus/smbconf.h>
+#include <dev/iicbus/iiconf.h>
+#include "smbus_if.h"
+#include "iicbus_if.h"
+#endif
+
+const char *
+bktr_name(bktr_ptr_t bktr)
+{
+  return bktr->bktr_xname;
+}
+
+
+#if (__FreeBSD__ == 2)
+typedef unsigned int uintptr_t;
+#endif
+#endif  /* __FreeBSD__ */
+
+
+/****************/
+/* *** BSDI *** */
+/****************/
+#ifdef __bsdi__
+#endif /* __bsdi__ */
+
+
+/**************************/
+/* *** OpenBSD/NetBSD *** */
+/**************************/
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/signalvar.h>
+#include <sys/vnode.h>
+
+#ifdef __NetBSD__
+#include <uvm/uvm_extern.h>
+#else
+#include <vm/vm.h>			/* for vtophys */
+#include <vm/pmap.h>			/* for vtophys */
+#endif
+
+#ifdef __OpenBSD__
+typedef unsigned long uintptr_t;
+typedef int intrmask_t;
+#else
+#include <sys/inttypes.h>		/* uintptr_t */
+#endif
+#include <dev/ic/bt8xx.h>
+#include <dev/pci/bktr/bktr_reg.h>
+#include <dev/pci/bktr/bktr_tuner.h>
+#include <dev/pci/bktr/bktr_card.h>
+#include <dev/pci/bktr/bktr_audio.h>
+#include <dev/pci/bktr/bktr_core.h>
+#include <dev/pci/bktr/bktr_os.h>
+
+static int bt848_format = -1;
+
+const char *
+bktr_name(bktr_ptr_t bktr)
+{
+        return (bktr->bktr_dev.dv_xname);
+}
+
+#endif /* __NetBSD__ || __OpenBSD__ */
+
+
+
+typedef u_char bool_t;
+
+#define BKTRPRI (PZERO+8)|PCATCH
+#define VBIPRI  (PZERO-4)|PCATCH
+
+
+/*
+ * memory allocated for DMA programs
+ */
+#define DMA_PROG_ALLOC		(8 * PAGE_SIZE)
+
+/* When to split a dma transfer , the bt848 has timing as well as
+   dma transfer size limitations so that we have to split dma
+   transfers into two dma requests 
+   */
+#define DMA_BT848_SPLIT 319*2
+
+/* 
+ * Allocate enough memory for:
+ *	768x576 RGB 16 or YUV (16 storage bits/pixel) = 884736 = 216 pages
+ *
+ * You may override this using the options "BROOKTREE_ALLOC_PAGES=value"
+ * in your  kernel configuration file.
+ */
+
+#ifndef BROOKTREE_ALLOC_PAGES
+#define BROOKTREE_ALLOC_PAGES	217*4
+#endif
+#define BROOKTREE_ALLOC		(BROOKTREE_ALLOC_PAGES * PAGE_SIZE)
+
+/* Definitions for VBI capture.
+ * There are 16 VBI lines in a PAL video field (32 in a frame),
+ * and we take 2044 samples from each line (placed in a 2048 byte buffer
+ * for alignment).
+ * VBI lines are held in a circular buffer before being read by a
+ * user program from /dev/vbi.
+ */
+
+#define MAX_VBI_LINES	      16   /* Maximum for all vidoe formats */
+#define VBI_LINE_SIZE         2048 /* Store upto 2048 bytes per line */
+#define VBI_BUFFER_ITEMS      20   /* Number of frames we buffer */
+#define VBI_DATA_SIZE         (VBI_LINE_SIZE * MAX_VBI_LINES * 2)
+#define VBI_BUFFER_SIZE       (VBI_DATA_SIZE * VBI_BUFFER_ITEMS)
+
+
+/*  Defines for fields  */
+#define ODD_F  0x01
+#define EVEN_F 0x02
+
+
+/*
+ * Parameters describing size of transmitted image.
+ */
+
+static struct format_params format_params[] = {
+/* # define BT848_IFORM_F_AUTO             (0x0) - don't matter. */
+  { 525, 26, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_AUTO,
+    12,  1600 },
+/* # define BT848_IFORM_F_NTSCM            (0x1) */
+  { 525, 26, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
+    12, 1600 },
+/* # define BT848_IFORM_F_NTSCJ            (0x2) */
+  { 525, 22, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
+    12, 1600 },
+/* # define BT848_IFORM_F_PALBDGHI         (0x3) */
+  { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1,
+    16,  2044 },
+/* # define BT848_IFORM_F_PALM             (0x4) */
+  { 525, 22, 480,  910, 135, 754, 640,  780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0,
+    12, 1600 },
+/* # define BT848_IFORM_F_PALN             (0x5) */
+  { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1,
+    16, 2044 },
+/* # define BT848_IFORM_F_SECAM            (0x6) */
+  { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0xa0, BT848_IFORM_X_XT1,
+    16, 2044 },
+/* # define BT848_IFORM_F_RSVD             (0x7) - ???? */
+  { 625, 32, 576, 1135, 186, 924, 768,  944, 25, 0x7f, 0x72, BT848_IFORM_X_XT0,
+    16, 2044 },
+};
+
+/*
+ * Table of supported Pixel Formats 
+ */
+
+static struct meteor_pixfmt_internal {
+	struct meteor_pixfmt public;
+	u_int                color_fmt;
+} pixfmt_table[] = {
+
+{ { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,  0x03e0,  0x001f }, 0,0 }, 0x33 },
+{ { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,  0x03e0,  0x001f }, 1,0 }, 0x33 },
+
+{ { 0, METEOR_PIXTYPE_RGB, 2, {   0xf800,  0x07e0,  0x001f }, 0,0 }, 0x22 },
+{ { 0, METEOR_PIXTYPE_RGB, 2, {   0xf800,  0x07e0,  0x001f }, 1,0 }, 0x22 },
+
+{ { 0, METEOR_PIXTYPE_RGB, 3, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x11 },
+
+{ { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,0 }, 0x00 },
+{ { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x00 },
+{ { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x00 },
+{ { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x00 },
+{ { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 },
+{ { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x44 },
+{ { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 },
+
+};
+#define PIXFMT_TABLE_SIZE ( sizeof(pixfmt_table) / sizeof(pixfmt_table[0]) )
+
+/*
+ * Table of Meteor-supported Pixel Formats (for SETGEO compatibility)
+ */
+
+/*  FIXME:  Also add YUV_422 and YUV_PACKED as well  */
+static struct {
+	u_long               meteor_format;
+	struct meteor_pixfmt public;
+} meteor_pixfmt_table[] = {
+    { METEOR_GEO_YUV_12,
+      { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }
+    },
+
+      /* FIXME: Should byte swap flag be on for this one; negative in drvr? */
+    { METEOR_GEO_YUV_422,
+      { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }
+    },
+    { METEOR_GEO_YUV_PACKED,
+      { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }
+    },
+    { METEOR_GEO_RGB16,
+      { 0, METEOR_PIXTYPE_RGB, 2, {   0x7c00,   0x03e0,   0x001f }, 0, 0 }
+    },
+    { METEOR_GEO_RGB24,
+      { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000, 0x00ff00, 0x0000ff }, 0, 0 }
+    },
+
+};
+#define METEOR_PIXFMT_TABLE_SIZE ( sizeof(meteor_pixfmt_table) / \
+				   sizeof(meteor_pixfmt_table[0]) )
+
+
+#define BSWAP (BT848_COLOR_CTL_BSWAP_ODD | BT848_COLOR_CTL_BSWAP_EVEN)
+#define WSWAP (BT848_COLOR_CTL_WSWAP_ODD | BT848_COLOR_CTL_WSWAP_EVEN)
+
+
+
+/* sync detect threshold */
+#if 0
+#define SYNC_LEVEL		(BT848_ADC_RESERVED |	\
+				 BT848_ADC_CRUSH)	/* threshold ~125 mV */
+#else
+#define SYNC_LEVEL		(BT848_ADC_RESERVED |	\
+				 BT848_ADC_SYNC_T)	/* threshold ~75 mV */
+#endif
+
+
+
+
+/* debug utility for holding previous INT_STAT contents */
+#define STATUS_SUM
+static u_long	status_sum = 0;
+
+/*
+ * defines to make certain bit-fiddles understandable
+ */
+#define FIFO_ENABLED		BT848_DMA_CTL_FIFO_EN
+#define RISC_ENABLED		BT848_DMA_CTL_RISC_EN
+#define FIFO_RISC_ENABLED	(BT848_DMA_CTL_FIFO_EN | BT848_DMA_CTL_RISC_EN)
+#define FIFO_RISC_DISABLED	0
+
+#define ALL_INTS_DISABLED	0
+#define ALL_INTS_CLEARED	0xffffffff
+#define CAPTURE_OFF		0
+
+#define BIT_SEVEN_HIGH		(1<<7)
+#define BIT_EIGHT_HIGH		(1<<8)
+
+#define I2C_BITS		(BT848_INT_RACK | BT848_INT_I2CDONE)
+#define TDEC_BITS               (BT848_INT_FDSR | BT848_INT_FBUS)
+
+
+
+static int		oformat_meteor_to_bt( u_long format );
+
+static u_int		pixfmt_swap_flags( int pixfmt );
+
+/*
+ * bt848 RISC programming routines.
+ */
+#ifdef BT848_DUMP
+static int	dump_bt848( bktr_ptr_t bktr );
+#endif
+
+static void	yuvpack_prog( bktr_ptr_t bktr, char i_flag, int cols,
+			      int rows,  int interlace );
+static void	yuv422_prog( bktr_ptr_t bktr, char i_flag, int cols,
+			     int rows, int interlace );
+static void	yuv12_prog( bktr_ptr_t bktr, char i_flag, int cols,
+			     int rows, int interlace );
+static void	rgb_prog( bktr_ptr_t bktr, char i_flag, int cols,
+			  int rows, int interlace );
+static void	rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols,
+			  int rows, int interlace );
+static void	build_dma_prog( bktr_ptr_t bktr, char i_flag );
+
+static bool_t   getline(bktr_reg_t *, int);
+static bool_t   notclipped(bktr_reg_t * , int , int);     
+static bool_t   split(bktr_reg_t *, volatile u_long **, int, u_long, int, 
+		      volatile u_char ** , int  );
+
+static void	start_capture( bktr_ptr_t bktr, unsigned type );
+static void	set_fps( bktr_ptr_t bktr, u_short fps );
+
+
+
+/*
+ * Remote Control Functions
+ */
+static void	remote_read(bktr_ptr_t bktr, struct bktr_remote *remote);
+
+
+/*
+ * ioctls common to both video & tuner.
+ */
+static int	common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg );
+
+
+#if !defined(BKTR_USE_FREEBSD_SMBUS)
+/*
+ * i2c primitives for low level control of i2c bus. Added for MSP34xx control
+ */
+static void     i2c_start( bktr_ptr_t bktr);
+static void     i2c_stop( bktr_ptr_t bktr);
+static int      i2c_write_byte( bktr_ptr_t bktr, unsigned char data);
+static int      i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last );
+#endif
+
+
+
+/*
+ * the common attach code, used by all OS versions.
+ */
+void 
+common_bktr_attach( bktr_ptr_t bktr, int unit, u_long pci_id, u_int rev )
+{
+	vm_offset_t	buf = 0;
+
+/***************************************/
+/* *** OS Specific memory routines *** */
+/***************************************/
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+        /* allocate space for dma program */
+        bktr->dma_prog = get_bktr_mem(bktr, &bktr->dm_prog,
+				      DMA_PROG_ALLOC);
+        bktr->odd_dma_prog = get_bktr_mem(bktr, &bktr->dm_oprog,
+					  DMA_PROG_ALLOC);
+
+	/* allocate space for the VBI buffer */
+	bktr->vbidata  = get_bktr_mem(bktr, &bktr->dm_vbidata,
+				      VBI_DATA_SIZE);
+	bktr->vbibuffer = get_bktr_mem(bktr, &bktr->dm_vbibuffer,
+				       VBI_BUFFER_SIZE);
+
+        /* allocate space for pixel buffer */
+        if ( BROOKTREE_ALLOC )
+                buf = get_bktr_mem(bktr, &bktr->dm_mem, BROOKTREE_ALLOC);
+        else
+                buf = 0;
+#endif
+
+#if defined(__FreeBSD__) || defined(__bsdi__)
+	int		need_to_allocate_memory = 1;
+
+/* If this is a module, check if there is any currently saved contiguous memory */
+#if defined(BKTR_FREEBSD_MODULE)
+	if (bktr_has_stored_addresses(unit) == 1) {
+		/* recover the addresses */
+		bktr->dma_prog     = bktr_retrieve_address(unit, BKTR_MEM_DMA_PROG);
+		bktr->odd_dma_prog = bktr_retrieve_address(unit, BKTR_MEM_ODD_DMA_PROG);
+		bktr->vbidata      = bktr_retrieve_address(unit, BKTR_MEM_VBIDATA);
+		bktr->vbibuffer    = bktr_retrieve_address(unit, BKTR_MEM_VBIBUFFER);
+		buf                = bktr_retrieve_address(unit, BKTR_MEM_BUF);
+		need_to_allocate_memory = 0;
+	}
+#endif
+
+	if (need_to_allocate_memory == 1) {
+		/* allocate space for dma program */
+		bktr->dma_prog     = get_bktr_mem(unit, DMA_PROG_ALLOC);
+		bktr->odd_dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC);
+
+		/* allocte space for the VBI buffer */
+		bktr->vbidata  = get_bktr_mem(unit, VBI_DATA_SIZE);
+		bktr->vbibuffer = get_bktr_mem(unit, VBI_BUFFER_SIZE);
+
+		/* allocate space for pixel buffer */
+		if ( BROOKTREE_ALLOC )
+			buf = get_bktr_mem(unit, BROOKTREE_ALLOC);
+		else
+			buf = 0;
+	}
+#endif	/* FreeBSD or BSDi */
+
+
+/* If this is a module, save the current contiguous memory */
+#if defined(BKTR_FREEBSD_MODULE)
+bktr_store_address(unit, BKTR_MEM_DMA_PROG,     bktr->dma_prog);
+bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog);
+bktr_store_address(unit, BKTR_MEM_VBIDATA,      bktr->vbidata);
+bktr_store_address(unit, BKTR_MEM_VBIBUFFER,    bktr->vbibuffer);
+bktr_store_address(unit, BKTR_MEM_BUF,          buf);
+#endif
+
+
+	if ( bootverbose ) {
+		printf("%s: buffer size %d, addr 0x%x\n",
+			bktr_name(bktr), BROOKTREE_ALLOC, vtophys(buf));
+	}
+
+	if ( buf != 0 ) {
+		bktr->bigbuf = buf;
+		bktr->alloc_pages = BROOKTREE_ALLOC_PAGES;
+		bzero((caddr_t) bktr->bigbuf, BROOKTREE_ALLOC);
+	} else {
+		bktr->alloc_pages = 0;
+	}
+		
+
+	bktr->flags = METEOR_INITALIZED | METEOR_AUTOMODE |
+		      METEOR_DEV0 | METEOR_RGB16;
+	bktr->dma_prog_loaded = FALSE;
+	bktr->cols = 640;
+	bktr->rows = 480;
+	bktr->frames = 1;		/* one frame */
+	bktr->format = METEOR_GEO_RGB16;
+	bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
+	bktr->pixfmt_compat = TRUE;
+
+
+	bktr->vbiinsert = 0;
+	bktr->vbistart = 0;
+	bktr->vbisize = 0;
+	bktr->vbiflags = 0;
+
+ 
+	/* using the pci device id and revision id */
+	/* and determine the card type            */
+	if (PCI_VENDOR(pci_id) == PCI_VENDOR_BROOKTREE)
+	{
+		switch (PCI_PRODUCT(pci_id)) {
+		case PCI_PRODUCT_BROOKTREE_BT848:
+			if (rev == 0x12)
+				bktr->id = BROOKTREE_848A;
+			else
+				bktr->id = BROOKTREE_848;
+			break;
+		case PCI_PRODUCT_BROOKTREE_BT849:
+			bktr->id = BROOKTREE_849A;
+			break;
+		case PCI_PRODUCT_BROOKTREE_BT878:
+			bktr->id = BROOKTREE_878;
+			break;
+		case PCI_PRODUCT_BROOKTREE_BT879:
+			bktr->id = BROOKTREE_879;
+			break;
+		}
+	};
+
+	bktr->clr_on_start = FALSE;
+
+	/* defaults for the tuner section of the card */
+	bktr->tflags = TUNER_INITALIZED;
+	bktr->tuner.frequency = 0;
+	bktr->tuner.channel = 0;
+	bktr->tuner.chnlset = DEFAULT_CHNLSET;
+	bktr->tuner.afc = 0;
+	bktr->tuner.radio_mode = 0;
+	bktr->audio_mux_select = 0;
+	bktr->audio_mute_state = FALSE;
+	bktr->bt848_card = -1;
+	bktr->bt848_tuner = -1;
+	bktr->reverse_mute = -1;
+	bktr->slow_msp_audio = 0;
+	bktr->msp_use_mono_source = 0;
+        bktr->msp_source_selected = -1;
+	bktr->audio_mux_present = 1;
+
+	probeCard( bktr, TRUE, unit );
+
+	/* Initialise any MSP34xx or TDA98xx audio chips */
+	init_audio_devices( bktr );
+
+}
+
+
+/* Copy the vbi lines from 'vbidata' into the circular buffer, 'vbibuffer'.
+ * The circular buffer holds 'n' fixed size data blocks. 
+ * vbisize   is the number of bytes in the circular buffer 
+ * vbiread   is the point we reading data out of the circular buffer 
+ * vbiinsert is the point we insert data into the circular buffer 
+ */
+static void vbidecode(bktr_ptr_t bktr) {
+        unsigned char *dest;
+	unsigned int *seq_dest;
+
+	/* Check if there is room in the buffer to insert the data. */
+	if (bktr->vbisize + VBI_DATA_SIZE > VBI_BUFFER_SIZE) return;
+
+	/* Copy the VBI data into the next free slot in the buffer. */
+	/* 'dest' is the point in vbibuffer where we want to insert new data */
+        dest = (unsigned char *)bktr->vbibuffer + bktr->vbiinsert;
+        memcpy(dest, (unsigned char*)bktr->vbidata, VBI_DATA_SIZE);
+
+	/* Write the VBI sequence number to the end of the vbi data */
+	/* This is used by the AleVT teletext program */
+	seq_dest = (unsigned int *)((unsigned char *)bktr->vbibuffer
+			+ bktr->vbiinsert
+			+ (VBI_DATA_SIZE - sizeof(bktr->vbi_sequence_number)));
+	*seq_dest = bktr->vbi_sequence_number;
+
+	/* And increase the VBI sequence number */
+	/* This can wrap around */
+	bktr->vbi_sequence_number++;
+
+
+	/* Increment the vbiinsert pointer */
+	/* This can wrap around */
+	bktr->vbiinsert += VBI_DATA_SIZE;
+	bktr->vbiinsert = (bktr->vbiinsert % VBI_BUFFER_SIZE);
+
+	/* And increase the amount of vbi data in the buffer */
+	bktr->vbisize = bktr->vbisize + VBI_DATA_SIZE;
+
+}
+
+
+/*
+ * the common interrupt handler.
+ * Returns a 0 or 1 depending on whether the interrupt has handled.
+ * In the OS specific section, bktr_intr() is defined which calls this
+ * common interrupt handler.
+ */
+int 
+common_bktr_intr( void *arg )
+{ 
+	bktr_ptr_t		bktr;
+	u_long			bktr_status;
+	u_char			dstatus;
+	u_long                  field;
+	u_long                  w_field;
+	u_long                  req_field;
+
+	bktr = (bktr_ptr_t) arg;
+
+	/*
+	 * check to see if any interrupts are unmasked on this device.  If
+	 * none are, then we likely got here by way of being on a PCI shared
+	 * interrupt dispatch list.
+	 */
+	if (INL(bktr, BKTR_INT_MASK) == ALL_INTS_DISABLED)
+	  	return 0;	/* bail out now, before we do something we
+				   shouldn't */
+
+	if (!(bktr->flags & METEOR_OPEN)) {
+		OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+		OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+		/* return; ?? */
+	}
+
+	/* record and clear the INTerrupt status bits */
+	bktr_status = INL(bktr, BKTR_INT_STAT);
+	OUTL(bktr, BKTR_INT_STAT, bktr_status & ~I2C_BITS);	/* don't touch i2c */
+
+	/* record and clear the device status register */
+	dstatus = INB(bktr, BKTR_DSTATUS);
+	OUTB(bktr, BKTR_DSTATUS, 0x00);
+
+#if defined( STATUS_SUM )
+	/* add any new device status or INTerrupt status bits */
+	status_sum |= (bktr_status & ~(BT848_INT_RSV0|BT848_INT_RSV1));
+	status_sum |= ((dstatus & (BT848_DSTATUS_COF|BT848_DSTATUS_LOF)) << 6);
+#endif /* STATUS_SUM */
+	/* printf( "%s: STATUS %x %x %x \n", bktr_name(bktr),
+		dstatus, bktr_status, INL(bktr, BKTR_RISC_COUNT) );
+	*/
+
+
+	/* if risc was disabled re-start process again */
+	/* if there was one of the following errors re-start again */
+	if ( !(bktr_status & BT848_INT_RISC_EN) ||
+	     ((bktr_status &(/* BT848_INT_FBUS   | */
+			     /* BT848_INT_FTRGT  | */
+			     /* BT848_INT_FDSR   | */
+			      BT848_INT_PPERR  |
+			      BT848_INT_RIPERR | BT848_INT_PABORT |
+			      BT848_INT_OCERR  | BT848_INT_SCERR) ) != 0) 
+		|| ((INB(bktr, BKTR_TDEC) == 0) && (bktr_status & TDEC_BITS)) ) { 
+
+		u_short	tdec_save = INB(bktr, BKTR_TDEC);
+
+		OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+		OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
+
+		OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+
+		/*  Reset temporal decimation counter  */
+		OUTB(bktr, BKTR_TDEC, 0);
+		OUTB(bktr, BKTR_TDEC, tdec_save);
+		
+		/*  Reset to no-fields captured state  */
+		if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
+			switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
+			case METEOR_ONLY_ODD_FIELDS:
+				bktr->flags |= METEOR_WANT_ODD;
+				break;
+			case METEOR_ONLY_EVEN_FIELDS:
+				bktr->flags |= METEOR_WANT_EVEN;
+				break;
+			default:
+				bktr->flags |= METEOR_WANT_MASK;
+				break;
+			}
+		}
+
+		OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
+		OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+		OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
+
+		OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
+				    BT848_INT_RISCI      |
+				    BT848_INT_VSYNC      |
+				    BT848_INT_FMTCHG);
+
+		OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
+		return 1;
+	}
+
+	/* If this is not a RISC program interrupt, return */
+	if (!(bktr_status & BT848_INT_RISCI))
+		return 0;
+
+/**
+	printf( "%s: intr status %x %x %x\n", bktr_name(bktr),
+		bktr_status, dstatus, INL(bktr, BKTR_RISC_COUNT) );
+ */
+
+
+	/*
+	 * Disable future interrupts if a capture mode is not selected.
+	 * This can happen when we are in the process of closing or 
+	 * changing capture modes, otherwise it shouldn't happen.
+	 */
+	if (!(bktr->flags & METEOR_CAP_MASK))
+		OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
+
+
+	/* Determine which field generated this interrupt */
+	field = ( bktr_status & BT848_INT_FIELD ) ? EVEN_F : ODD_F;
+
+
+	/*
+	 * Process the VBI data if it is being captured. We do this once
+	 * both Odd and Even VBI data is captured. Therefore we do this
+	 * in the Even field interrupt handler.
+	 */
+	if (  (bktr->vbiflags & VBI_CAPTURE)
+	    &&(bktr->vbiflags & VBI_OPEN)
+            &&(field==EVEN_F)) {
+		/* Put VBI data into circular buffer */
+               	vbidecode(bktr);
+
+		/* If someone is blocked on reading from /dev/vbi, wake them */
+		if (bktr->vbi_read_blocked) {
+			bktr->vbi_read_blocked = FALSE;
+          	     	wakeup(VBI_SLEEP);
+		}
+
+		/* If someone has a select() on /dev/vbi, inform them */
+#ifndef __OpenBSD__
+		if (bktr->vbi_select.si_pid) {
+#else
+		if (bktr->vbi_select.si_selpid) {
+#endif
+			selwakeup(&bktr->vbi_select);
+		}
+
+
+	}
+
+
+	/*
+	 *  Register the completed field
+	 *    (For dual-field mode, require fields from the same frame)
+	 */
+	switch ( bktr->flags & METEOR_WANT_MASK ) {
+		case METEOR_WANT_ODD  : w_field = ODD_F         ;  break;
+		case METEOR_WANT_EVEN : w_field = EVEN_F        ;  break;
+		default               : w_field = (ODD_F|EVEN_F);  break;
+	}
+	switch ( bktr->flags & METEOR_ONLY_FIELDS_MASK ) {
+		case METEOR_ONLY_ODD_FIELDS  : req_field = ODD_F  ;  break;
+		case METEOR_ONLY_EVEN_FIELDS : req_field = EVEN_F ;  break;
+		default                      : req_field = (ODD_F|EVEN_F);  
+			                       break;
+	}
+
+	if (( field == EVEN_F ) && ( w_field == EVEN_F ))
+		bktr->flags &= ~METEOR_WANT_EVEN;
+	else if (( field == ODD_F ) && ( req_field == ODD_F ) &&
+		 ( w_field == ODD_F ))
+		bktr->flags &= ~METEOR_WANT_ODD;
+	else if (( field == ODD_F ) && ( req_field == (ODD_F|EVEN_F) ) &&
+		 ( w_field == (ODD_F|EVEN_F) ))
+		bktr->flags &= ~METEOR_WANT_ODD;
+	else if (( field == ODD_F ) && ( req_field == (ODD_F|EVEN_F) ) &&
+		 ( w_field == ODD_F )) {
+		bktr->flags &= ~METEOR_WANT_ODD;
+		bktr->flags |=  METEOR_WANT_EVEN;
+	}
+	else {
+		/*  We're out of sync.  Start over.  */
+		if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
+			switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
+			case METEOR_ONLY_ODD_FIELDS:
+				bktr->flags |= METEOR_WANT_ODD;
+				break;
+			case METEOR_ONLY_EVEN_FIELDS:
+				bktr->flags |= METEOR_WANT_EVEN;
+				break;
+			default:
+				bktr->flags |= METEOR_WANT_MASK;
+				break;
+			}
+		}
+		return 1;
+	}
+
+	/*
+	 * If we have a complete frame.
+	 */
+	if (!(bktr->flags & METEOR_WANT_MASK)) {
+		bktr->frames_captured++;
+		/*
+		 * post the completion time. 
+		 */
+		if (bktr->flags & METEOR_WANT_TS) {
+			struct timeval *ts;
+			
+			if ((u_int) bktr->alloc_pages * PAGE_SIZE
+			   <= (bktr->frame_size + sizeof(struct timeval))) {
+				ts =(struct timeval *)bktr->bigbuf +
+				  bktr->frame_size;
+				/* doesn't work in synch mode except
+				 *  for first frame */
+				/* XXX */
+				microtime(ts);
+			}
+		}
+	
+
+		/*
+		 * Wake up the user in single capture mode.
+		 */
+		if (bktr->flags & METEOR_SINGLE) {
+
+			/* stop dma */
+			OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+
+			/* disable risc, leave fifo running */
+			OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+			wakeup(BKTR_SLEEP);
+		}
+
+		/*
+		 * If the user requested to be notified via signal,
+		 * let them know the frame is complete.
+		 */
+
+		if (bktr->proc && !(bktr->signal & METEOR_SIG_MODE_MASK))
+			psignal( bktr->proc,
+				 bktr->signal&(~METEOR_SIG_MODE_MASK) );
+
+		/*
+		 * Reset the want flags if in continuous or
+		 * synchronous capture mode.
+		 */
+/*
+* XXX NOTE (Luigi):
+* currently we only support 3 capture modes: odd only, even only,
+* odd+even interlaced (odd field first). A fourth mode (non interlaced,
+* either even OR odd) could provide 60 (50 for PAL) pictures per
+* second, but it would require this routine to toggle the desired frame
+* each time, and one more different DMA program for the Bt848.
+* As a consequence, this fourth mode is currently unsupported.
+*/
+
+		if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) {
+			switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
+			case METEOR_ONLY_ODD_FIELDS:
+				bktr->flags |= METEOR_WANT_ODD;
+				break;
+			case METEOR_ONLY_EVEN_FIELDS:
+				bktr->flags |= METEOR_WANT_EVEN;
+				break;
+			default:
+				bktr->flags |= METEOR_WANT_MASK;
+				break;
+			}
+		}
+	}
+
+	return 1;
+}
+
+
+
+
+/*
+ * 
+ */
+extern int bt848_format; /* used to set the default format, PAL or NTSC */
+int
+video_open( bktr_ptr_t bktr )
+{
+	int frame_rate, video_format=0;
+
+	if (bktr->flags & METEOR_OPEN)		/* device is busy */
+		return( EBUSY );
+
+	bktr->flags |= METEOR_OPEN;
+
+#ifdef BT848_DUMP
+	dump_bt848( bt848 );
+#endif
+
+        bktr->clr_on_start = FALSE;
+
+	OUTB(bktr, BKTR_DSTATUS, 0x00);			/* clear device status reg. */
+
+	OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
+
+#if BKTR_SYSTEM_DEFAULT == BROOKTREE_PAL
+	video_format = 0;
+#else
+	video_format = 1;
+#endif
+
+	if (bt848_format == 0 ) 
+	  video_format = 0;
+
+	if (bt848_format == 1 ) 
+	  video_format = 1;
+
+	if (video_format == 1 ) {
+	  OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_NTSCM);
+	  bktr->format_params = BT848_IFORM_F_NTSCM;
+
+	} else {
+	  OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_PALBDGHI);
+	  bktr->format_params = BT848_IFORM_F_PALBDGHI;
+
+	}
+
+	OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | format_params[bktr->format_params].iform_xtsel);
+
+	/* work around for new Hauppauge 878 cards */
+	if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
+	    (bktr->id==BROOKTREE_878 || bktr->id==BROOKTREE_879) )
+		OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
+	else
+		OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
+
+	OUTB(bktr, BKTR_ADELAY, format_params[bktr->format_params].adelay);
+	OUTB(bktr, BKTR_BDELAY, format_params[bktr->format_params].bdelay);
+	frame_rate    = format_params[bktr->format_params].frame_rate;
+
+	/* enable PLL mode using 28Mhz crystal for PAL/SECAM users */
+	if (bktr->xtal_pll_mode == BT848_USE_PLL) {
+		OUTB(bktr, BKTR_TGCTRL, 0);
+		OUTB(bktr, BKTR_PLL_F_LO, 0xf9);
+		OUTB(bktr, BKTR_PLL_F_HI, 0xdc);
+		OUTB(bktr, BKTR_PLL_F_XCI, 0x8e);
+	}
+
+	bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) | METEOR_DEV0;
+
+	bktr->max_clip_node = 0;
+
+	OUTB(bktr, BKTR_COLOR_CTL, BT848_COLOR_CTL_GAMMA | BT848_COLOR_CTL_RGB_DED);
+
+	OUTB(bktr, BKTR_E_HSCALE_LO, 170);
+	OUTB(bktr, BKTR_O_HSCALE_LO, 170);
+
+	OUTB(bktr, BKTR_E_DELAY_LO, 0x72);
+	OUTB(bktr, BKTR_O_DELAY_LO, 0x72);
+	OUTB(bktr, BKTR_E_SCLOOP, 0);
+	OUTB(bktr, BKTR_O_SCLOOP, 0);
+
+	OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
+	OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
+
+	bktr->fifo_errors = 0;
+	bktr->dma_errors = 0;
+	bktr->frames_captured = 0;
+	bktr->even_fields_captured = 0;
+	bktr->odd_fields_captured = 0;
+	bktr->proc = (struct proc *)0;
+	set_fps(bktr, frame_rate);
+	bktr->video.addr = 0;
+	bktr->video.width = 0;
+	bktr->video.banksize = 0;
+	bktr->video.ramsize = 0;
+	bktr->pixfmt_compat = TRUE;
+	bktr->format = METEOR_GEO_RGB16;
+	bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
+
+	bktr->capture_area_enabled = FALSE;
+
+	OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT);	/* if you take this out triton
+                                                   based motherboards will 
+						   operate unreliably */
+	return( 0 );
+}
+
+int
+vbi_open( bktr_ptr_t bktr )
+{
+	if (bktr->vbiflags & VBI_OPEN)		/* device is busy */
+		return( EBUSY );
+
+	bktr->vbiflags |= VBI_OPEN;
+
+	/* reset the VBI circular buffer pointers and clear the buffers */
+	bktr->vbiinsert = 0;
+	bktr->vbistart = 0;
+	bktr->vbisize = 0;
+	bktr->vbi_sequence_number = 0;
+	bktr->vbi_read_blocked = FALSE;
+
+	bzero((caddr_t) bktr->vbibuffer, VBI_BUFFER_SIZE);
+	bzero((caddr_t) bktr->vbidata,  VBI_DATA_SIZE);
+
+	return( 0 );
+}
+
+/*
+ * 
+ */
+int
+tuner_open( bktr_ptr_t bktr )
+{
+	if ( !(bktr->tflags & TUNER_INITALIZED) )	/* device not found */
+		return( ENXIO );	
+
+	if ( bktr->tflags & TUNER_OPEN )		/* already open */
+		return( 0 );
+
+	bktr->tflags |= TUNER_OPEN;
+	bktr->tuner.frequency = 0;
+	bktr->tuner.channel = 0;
+	bktr->tuner.chnlset = DEFAULT_CHNLSET;
+	bktr->tuner.afc = 0;
+	bktr->tuner.radio_mode = 0;
+
+	/* enable drivers on the GPIO port that control the MUXes */
+	OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | bktr->card.gpio_mux_bits);
+
+	/* unmute the audio stream */
+	set_audio( bktr, AUDIO_UNMUTE );
+
+	/* Initialise any audio chips, eg MSP34xx or TDA98xx */
+	init_audio_devices( bktr );
+	
+	return( 0 );
+}
+
+
+
+
+/*
+ * 
+ */
+int
+video_close( bktr_ptr_t bktr )
+{
+	bktr->flags &= ~(METEOR_OPEN     |
+			 METEOR_SINGLE   |
+			 METEOR_CAP_MASK |
+			 METEOR_WANT_MASK);
+
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+	OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
+
+	bktr->dma_prog_loaded = FALSE;
+	OUTB(bktr, BKTR_TDEC, 0);
+	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+
+/** FIXME: is 0xf magic, wouldn't 0x00 work ??? */
+	OUTL(bktr, BKTR_SRESET, 0xf);
+	OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
+
+	return( 0 );
+}
+
+
+/*
+ * tuner close handle,
+ *  place holder for tuner specific operations on a close.
+ */
+int
+tuner_close( bktr_ptr_t bktr )
+{
+	bktr->tflags &= ~TUNER_OPEN;
+
+	/* mute the audio by switching the mux */
+	set_audio( bktr, AUDIO_MUTE );
+
+	/* disable drivers on the GPIO port that control the MUXes */
+	OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) & ~bktr->card.gpio_mux_bits);
+
+	return( 0 );
+}
+
+int
+vbi_close( bktr_ptr_t bktr )
+{
+
+	bktr->vbiflags &= ~VBI_OPEN;
+
+	return( 0 );
+}
+
+/*
+ *
+ */
+int
+video_read(bktr_ptr_t bktr, int unit, dev_t dev, struct uio *uio)
+{
+        int             status;
+        int             count;
+
+
+	if (bktr->bigbuf == 0)	/* no frame buffer allocated (ioctl failed) */
+		return( ENOMEM );
+
+	if (bktr->flags & METEOR_CAP_MASK)
+		return( EIO );	/* already capturing */
+
+        OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
+
+
+	count = bktr->rows * bktr->cols * 
+		pixfmt_table[ bktr->pixfmt ].public.Bpp;
+
+	if ((int) uio->uio_iov->iov_len < count)
+		return( EINVAL );
+
+	bktr->flags &= ~(METEOR_CAP_MASK | METEOR_WANT_MASK);
+
+	/* capture one frame */
+	start_capture(bktr, METEOR_SINGLE);
+	/* wait for capture to complete */
+	OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
+	OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
+                            BT848_INT_RISCI      |
+                            BT848_INT_VSYNC      |
+                            BT848_INT_FMTCHG);
+
+
+	status = tsleep(BKTR_SLEEP, BKTRPRI, "captur", 0);
+	if (!status)		/* successful capture */
+		status = uiomove((caddr_t)bktr->bigbuf, count, uio);
+	else
+		printf ("%s: read: tsleep error %d\n",
+			bktr_name(bktr), status);
+
+	bktr->flags &= ~(METEOR_SINGLE | METEOR_WANT_MASK);
+
+	return( status );
+}
+
+/*
+ * Read VBI data from the vbi circular buffer
+ * The buffer holds vbi data blocks which are the same size
+ * vbiinsert is the position we will insert the next item into the buffer
+ * vbistart is the actual position in the buffer we want to read from
+ * vbisize is the exact number of bytes in the buffer left to read 
+ */
+int
+vbi_read(bktr_ptr_t bktr, struct uio *uio, int ioflag)
+{
+	int             readsize, readsize2;
+	int             status;
+
+
+	while(bktr->vbisize == 0) {
+		if (ioflag & IO_NDELAY) {
+			return EWOULDBLOCK;
+		}
+
+		bktr->vbi_read_blocked = TRUE;
+		if ((status = tsleep(VBI_SLEEP, VBIPRI, "vbi", 0))) {
+			return status;
+		}
+	}
+
+	/* Now we have some data to give to the user */
+			
+	/* We cannot read more bytes than there are in
+	 * the circular buffer
+	 */
+	readsize = (int)uio->uio_iov->iov_len;
+
+	if (readsize > bktr->vbisize) readsize = bktr->vbisize;
+
+	/* Check if we can read this number of bytes without having
+	 * to wrap around the circular buffer */
+	if((bktr->vbistart + readsize) >= VBI_BUFFER_SIZE) {
+		/* We need to wrap around */
+
+		readsize2 = VBI_BUFFER_SIZE - bktr->vbistart;
+               	status = uiomove((caddr_t)bktr->vbibuffer + bktr->vbistart, readsize2, uio);
+		status += uiomove((caddr_t)bktr->vbibuffer, (readsize - readsize2), uio);
+	} else {
+		/* We do not need to wrap around */
+		status = uiomove((caddr_t)bktr->vbibuffer + bktr->vbistart, readsize, uio);
+	}
+
+	/* Update the number of bytes left to read */
+	bktr->vbisize -= readsize;
+
+	/* Update vbistart */
+	bktr->vbistart += readsize;
+	bktr->vbistart = bktr->vbistart % VBI_BUFFER_SIZE; /* wrap around if needed */
+
+	return( status );
+
+}
+
+
+
+/*
+ * video ioctls
+ */
+int
+video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* pr )
+{
+	volatile u_char		c_temp;
+	unsigned int		temp;
+	unsigned int		temp_iform;
+	unsigned int		error;
+	struct meteor_geomet	*geo;
+	struct meteor_counts	*counts;
+	struct meteor_video	*video;
+	struct bktr_capture_area *cap_area;
+	vm_offset_t		buf;
+	int                     i;
+	char                    char_temp;
+
+	switch ( cmd ) {
+
+	case BT848SCLIP: /* set clip region */
+	    bktr->max_clip_node = 0;
+	    memcpy(&bktr->clip_list, arg, sizeof(bktr->clip_list));
+
+	    for (i = 0; i < BT848_MAX_CLIP_NODE; i++) {
+		if (bktr->clip_list[i].y_min ==  0 &&
+		    bktr->clip_list[i].y_max == 0)
+		    break;
+	    }
+	    bktr->max_clip_node = i;
+
+	    /* make sure that the list contains a valid clip secquence */
+	    /* the clip rectangles should be sorted by x then by y as the
+               second order sort key */
+
+	    /* clip rectangle list is terminated by y_min and y_max set to 0 */
+
+	    /* to disable clipping set  y_min and y_max to 0 in the first
+               clip rectangle . The first clip rectangle is clip_list[0].
+             */
+
+             
+                
+	    if (bktr->max_clip_node == 0 && 
+		(bktr->clip_list[0].y_min != 0 && 
+		 bktr->clip_list[0].y_max != 0)) {
+		return EINVAL;
+	    }
+
+	    for (i = 0; i < BT848_MAX_CLIP_NODE - 1 ; i++) {
+		if (bktr->clip_list[i].y_min == 0 &&
+		    bktr->clip_list[i].y_max == 0) {
+		    break;
+		}
+		if ( bktr->clip_list[i+1].y_min != 0 &&
+		     bktr->clip_list[i+1].y_max != 0 &&
+		     bktr->clip_list[i].x_min > bktr->clip_list[i+1].x_min ) {
+
+		    bktr->max_clip_node = 0;
+		    return (EINVAL);
+
+		 }
+
+		if (bktr->clip_list[i].x_min >= bktr->clip_list[i].x_max ||
+		    bktr->clip_list[i].y_min >= bktr->clip_list[i].y_max ||
+		    bktr->clip_list[i].x_min < 0 ||
+		    bktr->clip_list[i].x_max < 0 || 
+		    bktr->clip_list[i].y_min < 0 ||
+		    bktr->clip_list[i].y_max < 0 ) {
+		    bktr->max_clip_node = 0;
+		    return (EINVAL);
+		}
+	    }
+
+	    bktr->dma_prog_loaded = FALSE;
+
+	    break;
+
+	case METEORSTATUS:	/* get Bt848 status */
+		c_temp = INB(bktr, BKTR_DSTATUS);
+		temp = 0;
+		if (!(c_temp & 0x40)) temp |= METEOR_STATUS_HCLK;
+		if (!(c_temp & 0x10)) temp |= METEOR_STATUS_FIDT;
+		*(u_short *)arg = temp;
+		break;
+
+	case BT848SFMT:		/* set input format */
+		temp = *(unsigned long*)arg & BT848_IFORM_FORMAT;
+		temp_iform = INB(bktr, BKTR_IFORM);
+		temp_iform &= ~BT848_IFORM_FORMAT;
+		temp_iform &= ~BT848_IFORM_XTSEL;
+		OUTB(bktr, BKTR_IFORM, (temp_iform | temp | format_params[temp].iform_xtsel));
+		switch( temp ) {
+		case BT848_IFORM_F_AUTO:
+			bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
+			METEOR_AUTOMODE;
+			break;
+
+		case BT848_IFORM_F_NTSCM:
+		case BT848_IFORM_F_NTSCJ:
+			bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
+				METEOR_NTSC;
+			OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
+			OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
+			bktr->format_params = temp;
+			break;
+
+		case BT848_IFORM_F_PALBDGHI:
+		case BT848_IFORM_F_PALN:
+		case BT848_IFORM_F_SECAM:
+		case BT848_IFORM_F_RSVD:
+		case BT848_IFORM_F_PALM:
+			bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
+				METEOR_PAL;
+			OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay);
+			OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay);
+			bktr->format_params = temp;
+			break;
+
+		}
+		bktr->dma_prog_loaded = FALSE;		
+		break;
+
+	case METEORSFMT:	/* set input format */
+		temp_iform = INB(bktr, BKTR_IFORM);
+		temp_iform &= ~BT848_IFORM_FORMAT;
+		temp_iform &= ~BT848_IFORM_XTSEL;
+		switch(*(unsigned long *)arg & METEOR_FORM_MASK ) {
+		case 0:		/* default */
+		case METEOR_FMT_NTSC:
+			bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
+				METEOR_NTSC;
+			OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_NTSCM | 
+		                         format_params[BT848_IFORM_F_NTSCM].iform_xtsel);
+			OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_NTSCM].adelay);
+			OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_NTSCM].bdelay);
+			bktr->format_params = BT848_IFORM_F_NTSCM;
+			break;
+
+		case METEOR_FMT_PAL:
+			bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
+				METEOR_PAL;
+			OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_PALBDGHI |
+		                         format_params[BT848_IFORM_F_PALBDGHI].iform_xtsel);
+			OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_PALBDGHI].adelay);
+			OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_PALBDGHI].bdelay);
+			bktr->format_params = BT848_IFORM_F_PALBDGHI;
+			break;
+
+		case METEOR_FMT_AUTOMODE:
+			bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) |
+				METEOR_AUTOMODE;
+			OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_AUTO |
+		                         format_params[BT848_IFORM_F_AUTO].iform_xtsel);
+			break;
+
+		default:
+			return( EINVAL );
+		}
+		bktr->dma_prog_loaded = FALSE;		
+		break;
+
+	case METEORGFMT:	/* get input format */
+		*(u_long *)arg = bktr->flags & METEOR_FORM_MASK;
+		break;
+
+
+	case BT848GFMT:		/* get input format */
+	        *(u_long *)arg = INB(bktr, BKTR_IFORM) & BT848_IFORM_FORMAT;
+		break;
+ 
+	case METEORSCOUNT:	/* (re)set error counts */
+		counts = (struct meteor_counts *) arg;
+		bktr->fifo_errors = counts->fifo_errors;
+		bktr->dma_errors = counts->dma_errors;
+		bktr->frames_captured = counts->frames_captured;
+		bktr->even_fields_captured = counts->even_fields_captured;
+		bktr->odd_fields_captured = counts->odd_fields_captured;
+		break;
+
+	case METEORGCOUNT:	/* get error counts */
+		counts = (struct meteor_counts *) arg;
+		counts->fifo_errors = bktr->fifo_errors;
+		counts->dma_errors = bktr->dma_errors;
+		counts->frames_captured = bktr->frames_captured;
+		counts->even_fields_captured = bktr->even_fields_captured;
+		counts->odd_fields_captured = bktr->odd_fields_captured;
+		break;
+
+	case METEORGVIDEO:
+		video = (struct meteor_video *)arg;
+		video->addr = bktr->video.addr;
+		video->width = bktr->video.width;
+		video->banksize = bktr->video.banksize;
+		video->ramsize = bktr->video.ramsize;
+		break;
+
+	case METEORSVIDEO:
+		video = (struct meteor_video *)arg;
+		bktr->video.addr = video->addr;
+		bktr->video.width = video->width;
+		bktr->video.banksize = video->banksize;
+		bktr->video.ramsize = video->ramsize;
+		break;
+
+	case METEORSFPS:
+		set_fps(bktr, *(u_short *)arg);
+		break;
+
+	case METEORGFPS:
+		*(u_short *)arg = bktr->fps;
+		break;
+
+	case METEORSHUE:	/* set hue */
+		OUTB(bktr, BKTR_HUE, (*(u_char *) arg) & 0xff);
+		break;
+
+	case METEORGHUE:	/* get hue */
+		*(u_char *)arg = INB(bktr, BKTR_HUE);
+		break;
+
+	case METEORSBRIG:	/* set brightness */
+	        char_temp =    ( *(u_char *)arg & 0xff) - 128;
+		OUTB(bktr, BKTR_BRIGHT, char_temp);
+		
+		break;
+
+	case METEORGBRIG:	/* get brightness */
+		*(u_char *)arg = INB(bktr, BKTR_BRIGHT);
+		break;
+
+	case METEORSCSAT:	/* set chroma saturation */
+		temp = (int)*(u_char *)arg;
+
+		OUTB(bktr, BKTR_SAT_U_LO, (temp << 1) & 0xff);
+		OUTB(bktr, BKTR_SAT_V_LO, (temp << 1) & 0xff);
+		OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
+		                     & ~(BT848_E_CONTROL_SAT_U_MSB
+					 | BT848_E_CONTROL_SAT_V_MSB));
+		OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
+		                     & ~(BT848_O_CONTROL_SAT_U_MSB |
+					 BT848_O_CONTROL_SAT_V_MSB));
+
+		if ( temp & BIT_SEVEN_HIGH ) {
+		        OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL)
+			                     | (BT848_E_CONTROL_SAT_U_MSB
+						| BT848_E_CONTROL_SAT_V_MSB));
+			OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL)
+			                     | (BT848_O_CONTROL_SAT_U_MSB
+						| BT848_O_CONTROL_SAT_V_MSB));
+		}
+		break;
+
+	case METEORGCSAT:	/* get chroma saturation */
+		temp = (INB(bktr, BKTR_SAT_V_LO) >> 1) & 0xff;
+		if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
+			temp |= BIT_SEVEN_HIGH;
+		*(u_char *)arg = (u_char)temp;
+		break;
+
+	case METEORSCONT:	/* set contrast */
+		temp = (int)*(u_char *)arg & 0xff;
+		temp <<= 1;
+		OUTB(bktr, BKTR_CONTRAST_LO, temp & 0xff);
+		OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_CON_MSB);
+		OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_CON_MSB);
+		OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) |
+			(((temp & 0x100) >> 6 ) & BT848_E_CONTROL_CON_MSB));
+		OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) |
+			(((temp & 0x100) >> 6 ) & BT848_O_CONTROL_CON_MSB));
+		break;
+
+	case METEORGCONT:	/* get contrast */
+		temp = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
+		temp |= ((int)INB(bktr, BKTR_O_CONTROL) & 0x04) << 6;
+		*(u_char *)arg = (u_char)((temp >> 1) & 0xff);
+		break;
+
+	case BT848SCBUF:	/* set Clear-Buffer-on-start flag */
+		bktr->clr_on_start = (*(int *)arg != 0);
+		break;
+
+	case BT848GCBUF:	/* get Clear-Buffer-on-start flag */
+		*(int *)arg = (int) bktr->clr_on_start;
+		break;
+
+	case METEORSSIGNAL:
+		if(*(int *)arg == 0 || *(int *)arg >= NSIG) {
+			return( EINVAL );
+			break;
+		}
+		bktr->signal = *(int *) arg;
+		bktr->proc = pr;
+		break;
+
+	case METEORGSIGNAL:
+		*(int *)arg = bktr->signal;
+		break;
+
+	case METEORCAPTUR:
+		temp = bktr->flags;
+		switch (*(int *) arg) {
+		case METEOR_CAP_SINGLE:
+
+			if (bktr->bigbuf==0)	/* no frame buffer allocated */
+				return( ENOMEM );
+			/* already capturing */
+			if (temp & METEOR_CAP_MASK)
+				return( EIO );
+
+
+
+			start_capture(bktr, METEOR_SINGLE);
+
+			/* wait for capture to complete */
+			OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
+			OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+			OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
+
+			OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
+			     		    BT848_INT_RISCI      |
+					    BT848_INT_VSYNC      |
+					    BT848_INT_FMTCHG);
+
+			OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
+			error = tsleep(BKTR_SLEEP, BKTRPRI, "captur", hz);
+			if (error && (error != ERESTART)) {
+				/*  Here if we didn't get complete frame  */
+#ifdef DIAGNOSTIC
+				printf( "%s: ioctl: tsleep error %d %x\n",
+					bktr_name(bktr), error,
+					INL(bktr, BKTR_RISC_COUNT));
+#endif
+
+				/* stop dma */
+				OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+
+				/* disable risc, leave fifo running */
+				OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+			}
+
+			bktr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK);
+			/* FIXME: should we set bt848->int_stat ??? */
+			break;
+
+		case METEOR_CAP_CONTINOUS:
+			if (bktr->bigbuf==0)	/* no frame buffer allocated */
+				return( ENOMEM );
+			/* already capturing */
+			if (temp & METEOR_CAP_MASK)
+			    return( EIO );
+
+
+			start_capture(bktr, METEOR_CONTIN);
+
+			/* Clear the interrypt status register */
+			OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
+
+			OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+			OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
+			OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl);
+
+			OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
+					    BT848_INT_RISCI      |
+			                    BT848_INT_VSYNC      |
+					    BT848_INT_FMTCHG);
+#ifdef BT848_DUMP
+			dump_bt848( bt848 );
+#endif
+			break;
+		
+		case METEOR_CAP_STOP_CONT:
+			if (bktr->flags & METEOR_CONTIN) {
+				/* turn off capture */
+				OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+				OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF);
+				OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+				bktr->flags &=
+					~(METEOR_CONTIN | METEOR_WANT_MASK);
+
+			}
+		}
+		break;
+
+	case METEORSETGEO:
+		/* can't change parameters while capturing */
+		if (bktr->flags & METEOR_CAP_MASK)
+			return( EBUSY );
+
+
+		geo = (struct meteor_geomet *) arg;
+
+		error = 0;
+		/* Either even or odd, if even & odd, then these a zero */
+		if ((geo->oformat & METEOR_GEO_ODD_ONLY) &&
+			(geo->oformat & METEOR_GEO_EVEN_ONLY)) {
+			printf( "%s: ioctl: Geometry odd or even only.\n",
+				bktr_name(bktr));
+			return( EINVAL );
+		}
+
+		/* set/clear even/odd flags */
+		if (geo->oformat & METEOR_GEO_ODD_ONLY)
+			bktr->flags |= METEOR_ONLY_ODD_FIELDS;
+		else
+			bktr->flags &= ~METEOR_ONLY_ODD_FIELDS;
+		if (geo->oformat & METEOR_GEO_EVEN_ONLY)
+			bktr->flags |= METEOR_ONLY_EVEN_FIELDS;
+		else
+			bktr->flags &= ~METEOR_ONLY_EVEN_FIELDS;
+
+		if (geo->columns <= 0) {
+			printf(
+			"%s: ioctl: %d: columns must be greater than zero.\n",
+				bktr_name(bktr), geo->columns);
+			error = EINVAL;
+		}
+		else if ((geo->columns & 0x3fe) != geo->columns) {
+			printf(
+			"%s: ioctl: %d: columns too large or not even.\n",
+				bktr_name(bktr), geo->columns);
+			error = EINVAL;
+		}
+
+		if (geo->rows <= 0) {
+			printf(
+			"%s: ioctl: %d: rows must be greater than zero.\n",
+				bktr_name(bktr), geo->rows);
+			error = EINVAL;
+		}
+		else if (((geo->rows & 0x7fe) != geo->rows) ||
+			((geo->oformat & METEOR_GEO_FIELD_MASK) &&
+				((geo->rows & 0x3fe) != geo->rows)) ) {
+			printf(
+			"%s: ioctl: %d: rows too large or not even.\n",
+				bktr_name(bktr), geo->rows);
+			error = EINVAL;
+		}
+
+		if (geo->frames > 32) {
+			printf("%s: ioctl: too many frames.\n",
+			       bktr_name(bktr));
+
+			error = EINVAL;
+		}
+
+		if (error)
+			return( error );
+
+		bktr->dma_prog_loaded = FALSE;
+		OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+
+		OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+
+		if ((temp=(geo->rows * geo->columns * geo->frames * 2))) {
+			if (geo->oformat & METEOR_GEO_RGB24) temp = temp * 2;
+
+			/* meteor_mem structure for SYNC Capture */
+			if (geo->frames > 1) temp += PAGE_SIZE;
+
+			temp = btoc(temp);
+			if ((int) temp > bktr->alloc_pages
+			    && bktr->video.addr == 0) {
+
+/*****************************/
+/* *** OS Dependant code *** */
+/*****************************/
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+                                bus_dmamap_t dmamap;
+
+                                buf = get_bktr_mem(bktr, &dmamap,
+                                                   temp * PAGE_SIZE);
+                                if (buf != 0) {
+                                        free_bktr_mem(bktr, bktr->dm_mem,
+                                                      bktr->bigbuf);
+                                        bktr->dm_mem = dmamap;
+
+#else
+                                buf = get_bktr_mem(unit, temp*PAGE_SIZE);
+                                if (buf != 0) {
+                                        kmem_free(kernel_map, bktr->bigbuf,
+                                          (bktr->alloc_pages * PAGE_SIZE));
+#endif                                          
+
+					bktr->bigbuf = buf;
+					bktr->alloc_pages = temp;
+					if (bootverbose)
+						printf(
+				"%s: ioctl: Allocating %d bytes\n",
+							bktr_name(bktr), temp*PAGE_SIZE);
+				}
+				else
+					error = ENOMEM;
+			}
+		}
+
+		if (error)
+			return error;
+
+		bktr->rows = geo->rows;
+		bktr->cols = geo->columns;
+		bktr->frames = geo->frames;
+
+		/*  Pixel format (if in meteor pixfmt compatibility mode)  */
+		if ( bktr->pixfmt_compat ) {
+			bktr->format = METEOR_GEO_YUV_422;
+			switch (geo->oformat & METEOR_GEO_OUTPUT_MASK) {
+			case 0:			/* default */
+			case METEOR_GEO_RGB16:
+				    bktr->format = METEOR_GEO_RGB16;
+				    break;
+			case METEOR_GEO_RGB24:
+				    bktr->format = METEOR_GEO_RGB24;
+				    break;
+			case METEOR_GEO_YUV_422:
+				    bktr->format = METEOR_GEO_YUV_422;
+                                    if (geo->oformat & METEOR_GEO_YUV_12) 
+					bktr->format = METEOR_GEO_YUV_12;
+				    break;
+			case METEOR_GEO_YUV_PACKED:
+				    bktr->format = METEOR_GEO_YUV_PACKED;
+				    break;
+			}
+			bktr->pixfmt = oformat_meteor_to_bt( bktr->format );
+		}
+
+		if (bktr->flags & METEOR_CAP_MASK) {
+
+			if (bktr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
+				switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
+				case METEOR_ONLY_ODD_FIELDS:
+					bktr->flags |= METEOR_WANT_ODD;
+					break;
+				case METEOR_ONLY_EVEN_FIELDS:
+					bktr->flags |= METEOR_WANT_EVEN;
+					break;
+				default:
+					bktr->flags |= METEOR_WANT_MASK;
+					break;
+				}
+
+				start_capture(bktr, METEOR_CONTIN);
+				OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
+				OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED);
+				OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol);
+				OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT |
+						    BT848_INT_VSYNC      |
+						    BT848_INT_FMTCHG);
+			}
+		}
+		break;
+	/* end of METEORSETGEO */
+
+	/* FIXME. The Capture Area currently has the following restrictions:
+	GENERAL
+	 y_offset may need to be even in interlaced modes
+	RGB24 - Interlaced mode
+	 x_size must be greater than or equal to 1.666*METEORSETGEO width (cols)
+	 y_size must be greater than or equal to METEORSETGEO height (rows)
+	RGB24 - Even Only (or Odd Only) mode
+	 x_size must be greater than or equal to 1.666*METEORSETGEO width (cols)
+	 y_size must be greater than or equal to 2*METEORSETGEO height (rows)
+	YUV12 - Interlaced mode
+	 x_size must be greater than or equal to METEORSETGEO width (cols)
+	 y_size must be greater than or equal to METEORSETGEO height (rows)
+	YUV12 - Even Only (or Odd Only) mode
+	 x_size must be greater than or equal to METEORSETGEO width (cols)
+	 y_size must be greater than or equal to 2*METEORSETGEO height (rows)
+	*/
+
+	case BT848_SCAPAREA: /* set capture area of each video frame */
+		/* can't change parameters while capturing */
+		if (bktr->flags & METEOR_CAP_MASK)
+			return( EBUSY );
+
+		cap_area = (struct bktr_capture_area *) arg;
+		bktr->capture_area_x_offset = cap_area->x_offset;
+		bktr->capture_area_y_offset = cap_area->y_offset;
+		bktr->capture_area_x_size   = cap_area->x_size;
+		bktr->capture_area_y_size   = cap_area->y_size;
+		bktr->capture_area_enabled  = TRUE;
+ 
+		bktr->dma_prog_loaded = FALSE;
+		break;
+   
+	case BT848_GCAPAREA: /* get capture area of each video frame */
+		cap_area = (struct bktr_capture_area *) arg;
+		if (bktr->capture_area_enabled == FALSE) {
+			cap_area->x_offset = 0;
+			cap_area->y_offset = 0;
+			cap_area->x_size   = format_params[
+				bktr->format_params].scaled_hactive;
+			cap_area->y_size   = format_params[
+				bktr->format_params].vactive;
+		} else {
+			cap_area->x_offset = bktr->capture_area_x_offset;
+			cap_area->y_offset = bktr->capture_area_y_offset;
+			cap_area->x_size   = bktr->capture_area_x_size;
+			cap_area->y_size   = bktr->capture_area_y_size;
+		}
+		break;
+
+	default:
+		return common_ioctl( bktr, cmd, arg );
+	}
+
+	return( 0 );
+}
+
+/*
+ * tuner ioctls
+ */
+int
+tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* pr )
+{
+	int		tmp_int;
+	unsigned int	temp, temp1;
+	int		offset;
+	int		count;
+	u_char		*buf;
+	u_long          par;
+	u_char          write;
+	int             i2c_addr;
+	int             i2c_port;
+	u_long          data;
+
+	switch ( cmd ) {
+
+	case REMOTE_GETKEY:
+		/* Read the last key pressed by the Remote Control */
+		if (bktr->remote_control == 0) return (EINVAL);
+		remote_read(bktr, (struct bktr_remote *)arg);
+		break;
+
+#if defined( TUNER_AFC )
+	case TVTUNER_SETAFC:
+		bktr->tuner.afc = (*(int *)arg != 0);
+		break;
+
+	case TVTUNER_GETAFC:
+		*(int *)arg = bktr->tuner.afc;
+		/* XXX Perhaps use another bit to indicate AFC success? */
+		break;
+#endif /* TUNER_AFC */
+
+	case TVTUNER_SETCHNL:
+		temp_mute( bktr, TRUE );
+		temp = tv_channel( bktr, (int)*(unsigned long *)arg );
+		if ( temp < 0 ) {
+			temp_mute( bktr, FALSE );
+			return( EINVAL );
+		}
+		*(unsigned long *)arg = temp;
+
+		/* after every channel change, we must restart the MSP34xx */
+		/* audio chip to reselect NICAM STEREO or MONO audio */
+		if ( bktr->card.msp3400c )
+		  msp_autodetect( bktr );
+
+		/* after every channel change, we must restart the DPL35xx */
+		if ( bktr->card.dpl3518a )
+		  dpl_autodetect( bktr );
+
+		temp_mute( bktr, FALSE );
+		break;
+
+	case TVTUNER_GETCHNL:
+		*(unsigned long *)arg = bktr->tuner.channel;
+		break;
+
+	case TVTUNER_SETTYPE:
+		temp = *(unsigned long *)arg;
+		if ( (temp < CHNLSET_MIN) || (temp > CHNLSET_MAX) )
+			return( EINVAL );
+		bktr->tuner.chnlset = temp;
+		break;
+
+	case TVTUNER_GETTYPE:
+		*(unsigned long *)arg = bktr->tuner.chnlset;
+		break;
+
+	case TVTUNER_GETSTATUS:
+		temp = get_tuner_status( bktr );
+		*(unsigned long *)arg = temp & 0xff;
+		break;
+
+	case TVTUNER_SETFREQ:
+		temp_mute( bktr, TRUE );
+		temp = tv_freq( bktr, (int)*(unsigned long *)arg, TV_FREQUENCY);
+		temp_mute( bktr, FALSE );
+		if ( temp < 0 ) {
+			temp_mute( bktr, FALSE );
+			return( EINVAL );
+		}
+		*(unsigned long *)arg = temp;
+
+		/* after every channel change, we must restart the MSP34xx */
+		/* audio chip to reselect NICAM STEREO or MONO audio */
+		if ( bktr->card.msp3400c )
+		  msp_autodetect( bktr );
+
+		/* after every channel change, we must restart the DPL35xx */
+		if ( bktr->card.dpl3518a )
+		  dpl_autodetect( bktr );
+
+		temp_mute( bktr, FALSE );
+		break;
+
+	case TVTUNER_GETFREQ:
+		*(unsigned long *)arg = bktr->tuner.frequency;
+		break;
+
+	case TVTUNER_GETCHNLSET:
+		return tuner_getchnlset((struct bktr_chnlset *)arg);
+
+	case BT848_SAUDIO:	/* set audio channel */
+		if ( set_audio( bktr, *(int*)arg ) < 0 )
+			return( EIO );
+		break;
+
+	/* hue is a 2's compliment number, -90' to +89.3' in 0.7' steps */
+	case BT848_SHUE:	/* set hue */
+		OUTB(bktr, BKTR_HUE, (u_char)(*(int*)arg & 0xff));
+		break;
+
+	case BT848_GHUE:	/* get hue */
+		*(int*)arg = (signed char)(INB(bktr, BKTR_HUE) & 0xff);
+		break;
+
+	/* brightness is a 2's compliment #, -50 to +%49.6% in 0.39% steps */
+	case BT848_SBRIG:	/* set brightness */
+		OUTB(bktr, BKTR_BRIGHT, (u_char)(*(int *)arg & 0xff));
+		break;
+
+	case BT848_GBRIG:	/* get brightness */
+		*(int *)arg = (signed char)(INB(bktr, BKTR_BRIGHT) & 0xff);
+		break;
+
+	/*  */
+	case BT848_SCSAT:	/* set chroma saturation */
+		tmp_int = *(int*)arg;
+
+		temp = INB(bktr, BKTR_E_CONTROL);
+		temp1 = INB(bktr, BKTR_O_CONTROL);
+		if ( tmp_int & BIT_EIGHT_HIGH ) {
+			temp |= (BT848_E_CONTROL_SAT_U_MSB |
+				 BT848_E_CONTROL_SAT_V_MSB);
+			temp1 |= (BT848_O_CONTROL_SAT_U_MSB |
+				  BT848_O_CONTROL_SAT_V_MSB);
+		}
+		else {
+			temp &= ~(BT848_E_CONTROL_SAT_U_MSB |
+				  BT848_E_CONTROL_SAT_V_MSB);
+			temp1 &= ~(BT848_O_CONTROL_SAT_U_MSB |
+				   BT848_O_CONTROL_SAT_V_MSB);
+		}
+
+		OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
+		OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
+		OUTB(bktr, BKTR_E_CONTROL, temp);
+		OUTB(bktr, BKTR_O_CONTROL, temp1);
+		break;
+
+	case BT848_GCSAT:	/* get chroma saturation */
+		tmp_int = (int)(INB(bktr, BKTR_SAT_V_LO) & 0xff);
+		if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
+			tmp_int |= BIT_EIGHT_HIGH;
+		*(int*)arg = tmp_int;
+		break;
+
+	/*  */
+	case BT848_SVSAT:	/* set chroma V saturation */
+		tmp_int = *(int*)arg;
+
+		temp = INB(bktr, BKTR_E_CONTROL);
+		temp1 = INB(bktr, BKTR_O_CONTROL);
+		if ( tmp_int & BIT_EIGHT_HIGH) {
+			temp |= BT848_E_CONTROL_SAT_V_MSB;
+			temp1 |= BT848_O_CONTROL_SAT_V_MSB;
+		}
+		else {
+			temp &= ~BT848_E_CONTROL_SAT_V_MSB;
+			temp1 &= ~BT848_O_CONTROL_SAT_V_MSB;
+		}
+
+		OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff));
+		OUTB(bktr, BKTR_E_CONTROL, temp);
+		OUTB(bktr, BKTR_O_CONTROL, temp1);
+		break;
+
+	case BT848_GVSAT:	/* get chroma V saturation */
+		tmp_int = (int)INB(bktr, BKTR_SAT_V_LO) & 0xff;
+		if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB )
+			tmp_int |= BIT_EIGHT_HIGH;
+		*(int*)arg = tmp_int;
+		break;
+
+	/*  */
+	case BT848_SUSAT:	/* set chroma U saturation */
+		tmp_int = *(int*)arg;
+
+		temp = INB(bktr, BKTR_E_CONTROL);
+		temp1 = INB(bktr, BKTR_O_CONTROL);
+		if ( tmp_int & BIT_EIGHT_HIGH ) {
+			temp |= BT848_E_CONTROL_SAT_U_MSB;
+			temp1 |= BT848_O_CONTROL_SAT_U_MSB;
+		}
+		else {
+			temp &= ~BT848_E_CONTROL_SAT_U_MSB;
+			temp1 &= ~BT848_O_CONTROL_SAT_U_MSB;
+		}
+
+		OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff));
+		OUTB(bktr, BKTR_E_CONTROL, temp);
+		OUTB(bktr, BKTR_O_CONTROL, temp1);
+		break;
+
+	case BT848_GUSAT:	/* get chroma U saturation */
+		tmp_int = (int)INB(bktr, BKTR_SAT_U_LO) & 0xff;
+		if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_U_MSB )
+			tmp_int |= BIT_EIGHT_HIGH;
+		*(int*)arg = tmp_int;
+		break;
+
+/* lr 970528 luma notch etc - 3 high bits of e_control/o_control */
+
+	case BT848_SLNOTCH:	/* set luma notch */
+		tmp_int = (*(int *)arg & 0x7) << 5 ;
+		OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~0xe0);
+		OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~0xe0);
+		OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | tmp_int);
+		OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | tmp_int);
+		break;
+
+	case BT848_GLNOTCH:	/* get luma notch */
+		*(int *)arg = (int) ( (INB(bktr, BKTR_E_CONTROL) & 0xe0) >> 5) ;
+		break;
+
+
+	/*  */
+	case BT848_SCONT:	/* set contrast */
+		tmp_int = *(int*)arg;
+
+		temp = INB(bktr, BKTR_E_CONTROL);
+		temp1 = INB(bktr, BKTR_O_CONTROL);
+		if ( tmp_int & BIT_EIGHT_HIGH ) {
+			temp |= BT848_E_CONTROL_CON_MSB;
+			temp1 |= BT848_O_CONTROL_CON_MSB;
+		}
+		else {
+			temp &= ~BT848_E_CONTROL_CON_MSB;
+			temp1 &= ~BT848_O_CONTROL_CON_MSB;
+		}
+
+		OUTB(bktr, BKTR_CONTRAST_LO, (u_char)(tmp_int & 0xff));
+		OUTB(bktr, BKTR_E_CONTROL, temp);
+		OUTB(bktr, BKTR_O_CONTROL, temp1);
+		break;
+
+	case BT848_GCONT:	/* get contrast */
+		tmp_int = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff;
+		if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_CON_MSB )
+			tmp_int |= BIT_EIGHT_HIGH;
+		*(int*)arg = tmp_int;
+		break;
+
+		/*  FIXME:  SCBARS and CCBARS require a valid int *        */
+		/*    argument to succeed, but its not used; consider      */
+		/*    using the arg to store the on/off state so           */
+		/*    there's only one ioctl() needed to turn cbars on/off */
+	case BT848_SCBARS:	/* set colorbar output */
+		OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_COLOR_BARS);
+		break;
+
+	case BT848_CCBARS:	/* clear colorbar output */
+		OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) & ~(BT848_COLOR_CTL_COLOR_BARS));
+		break;
+
+	case BT848_GAUDIO:	/* get audio channel */
+		temp = bktr->audio_mux_select;
+		if ( bktr->audio_mute_state == TRUE )
+			temp |= AUDIO_MUTE;
+		*(int*)arg = temp;
+		break;
+
+	case BT848_SBTSC:	/* set audio channel */
+		if ( set_BTSC( bktr, *(int*)arg ) < 0 )
+			return( EIO );
+		break;
+
+	case BT848_WEEPROM:	/* write eeprom */
+		offset = (((struct eeProm *)arg)->offset);
+		count = (((struct eeProm *)arg)->count);
+		buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
+		if ( writeEEProm( bktr, offset, count, buf ) < 0 )
+			return( EIO );
+		break;
+
+	case BT848_REEPROM:	/* read eeprom */
+		offset = (((struct eeProm *)arg)->offset);
+		count = (((struct eeProm *)arg)->count);
+		buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
+		if ( readEEProm( bktr, offset, count, buf ) < 0 )
+			return( EIO );
+		break;
+
+	case BT848_SIGNATURE:
+		offset = (((struct eeProm *)arg)->offset);
+		count = (((struct eeProm *)arg)->count);
+		buf = &(((struct eeProm *)arg)->bytes[ 0 ]);
+		if ( signCard( bktr, offset, count, buf ) < 0 )
+			return( EIO );
+		break;
+
+        /* Ioctl's for direct gpio access */
+#ifdef BKTR_GPIO_ACCESS
+        case BT848_GPIO_GET_EN:
+                *(int*)arg = INL(bktr, BKTR_GPIO_OUT_EN);
+                break;
+
+        case BT848_GPIO_SET_EN:
+                OUTL(bktr, BKTR_GPIO_OUT_EN, *(int*)arg);
+                break;
+
+        case BT848_GPIO_GET_DATA:
+                *(int*)arg = INL(bktr, BKTR_GPIO_DATA);
+                break;
+
+        case BT848_GPIO_SET_DATA:
+                OUTL(bktr, BKTR_GPIO_DATA, *(int*)arg);
+                break;
+#endif /* BKTR_GPIO_ACCESS */
+
+	/* Ioctl's for running the tuner device in radio mode		*/
+
+	case RADIO_GETMODE:
+            *(unsigned char *)arg = bktr->tuner.radio_mode;
+	    break;
+
+	case RADIO_SETMODE:
+            bktr->tuner.radio_mode = *(unsigned char *)arg;
+            break;
+
+ 	case RADIO_GETFREQ:
+            *(unsigned long *)arg = bktr->tuner.frequency;
+            break;
+
+	case RADIO_SETFREQ:
+	    /* The argument to this ioctl is NOT freq*16. It is
+	    ** freq*100.
+	    */
+
+            temp=(int)*(unsigned long *)arg;
+
+#ifdef BKTR_RADIO_DEBUG
+	    printf("%s: arg=%d temp=%d\n", bktr_name(bktr),
+		   (int)*(unsigned long *)arg, temp);
+#endif
+
+#ifndef BKTR_RADIO_NOFREQCHECK
+	    /* According to the spec. sheet the band: 87.5MHz-108MHz	*/
+	    /* is supported.						*/
+	    if(temp<8750 || temp>10800) {
+	      printf("%s: Radio frequency out of range\n", bktr_name(bktr));
+	      return(EINVAL);
+	      }
+#endif
+	    temp_mute( bktr, TRUE );
+	    temp = tv_freq( bktr, temp, FM_RADIO_FREQUENCY );
+	    temp_mute( bktr, FALSE );
+#ifdef BKTR_RADIO_DEBUG
+  if(temp)
+    printf("%s: tv_freq returned: %d\n", bktr_name(bktr), temp);
+#endif
+	    if ( temp < 0 )
+		    return( EINVAL );
+	    *(unsigned long *)arg = temp;
+	    break;
+
+	/* Luigi's I2CWR ioctl */ 
+	case BT848_I2CWR:
+		par = *(u_long *)arg;
+		write = (par >> 24) & 0xff ;
+		i2c_addr = (par >> 16) & 0xff ;
+		i2c_port = (par >> 8) & 0xff ;
+		data = (par) & 0xff ;
+ 
+		if (write) { 
+			i2cWrite( bktr, i2c_addr, i2c_port, data);
+		} else {
+			data = i2cRead( bktr, i2c_addr);
+		}
+		*(u_long *)arg = (par & 0xffffff00) | ( data & 0xff );
+		break;
+
+
+#ifdef BT848_MSP_READ
+	/* I2C ioctls to allow userland access to the MSP chip */
+	case BT848_MSP_READ:
+		{
+		struct bktr_msp_control *msp;
+		msp = (struct bktr_msp_control *) arg;
+		msp->data = msp_dpl_read(bktr, bktr->msp_addr,
+		                         msp->function, msp->address);
+		break;
+		}
+
+	case BT848_MSP_WRITE:
+		{
+		struct bktr_msp_control *msp;
+		msp = (struct bktr_msp_control *) arg;
+		msp_dpl_write(bktr, bktr->msp_addr, msp->function,
+		             msp->address, msp->data );
+		break;
+		}
+
+	case BT848_MSP_RESET:
+		msp_dpl_reset(bktr, bktr->msp_addr);
+		break;
+#endif
+
+	default:
+		return common_ioctl( bktr, cmd, arg );
+	}
+
+	return( 0 );
+}
+
+
+/*
+ * common ioctls
+ */
+int
+common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg )
+{
+        int                           pixfmt;
+	unsigned int	              temp;
+	struct meteor_pixfmt          *pf_pub;
+
+	switch (cmd) {
+
+	case METEORSINPUT:	/* set input device */
+		/*Bt848 has 3 MUX Inputs. Bt848A/849A/878/879 has 4 MUX Inputs*/
+		/* On the original bt848 boards, */
+		/*   Tuner is MUX0, RCA is MUX1, S-Video is MUX2 */
+		/* On the Hauppauge bt878 boards, */
+		/*   Tuner is MUX0, RCA is MUX3 */
+		/* Unfortunatly Meteor driver codes DEV_RCA as DEV_0, so we */
+		/* stick with this system in our Meteor Emulation */
+
+		switch(*(unsigned long *)arg & METEOR_DEV_MASK) {
+
+		/* this is the RCA video input */
+		case 0:		/* default */
+		case METEOR_INPUT_DEV0:
+		  /* METEOR_INPUT_DEV_RCA: */
+		        bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
+			  | METEOR_DEV0;
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM)
+			                 & ~BT848_IFORM_MUXSEL);
+
+			/* work around for new Hauppauge 878 cards */
+			if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
+				(bktr->id==BROOKTREE_878 ||
+				 bktr->id==BROOKTREE_879) )
+				OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
+			else
+				OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
+
+			OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
+			OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
+			set_audio( bktr, AUDIO_EXTERN );
+			break;
+
+		/* this is the tuner input */
+		case METEOR_INPUT_DEV1:
+			bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
+				| METEOR_DEV1;
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX0);
+			OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
+			OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
+			set_audio( bktr, AUDIO_TUNER );
+			break;
+
+		/* this is the S-VHS input, but with a composite camera */
+		case METEOR_INPUT_DEV2:
+			bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
+				| METEOR_DEV2;
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
+			OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
+			OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_O_CONTROL_COMP);
+			set_audio( bktr, AUDIO_EXTERN );
+			break;
+
+		/* this is the S-VHS input */
+		case METEOR_INPUT_DEV_SVIDEO:
+			bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
+				| METEOR_DEV_SVIDEO;
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2);
+			OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_COMP);
+			OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_COMP);
+			set_audio( bktr, AUDIO_EXTERN );
+			break;
+
+		case METEOR_INPUT_DEV3:
+		  if ((bktr->id == BROOKTREE_848A) ||
+		      (bktr->id == BROOKTREE_849A) ||
+		      (bktr->id == BROOKTREE_878) ||
+		      (bktr->id == BROOKTREE_879) ) {
+			bktr->flags = (bktr->flags & ~METEOR_DEV_MASK)
+				| METEOR_DEV3;
+			OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL);
+
+			/* work around for new Hauppauge 878 cards */
+			if ((bktr->card.card_id == CARD_HAUPPAUGE) &&
+				(bktr->id==BROOKTREE_878 ||
+				 bktr->id==BROOKTREE_879) )
+				OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1);
+			else
+				OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3);
+
+			OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP);
+			OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP);
+			set_audio( bktr, AUDIO_EXTERN );
+
+			break;
+		  }	
+
+		default:
+			return( EINVAL );
+		}
+		break;
+
+	case METEORGINPUT:	/* get input device */
+		*(u_long *)arg = bktr->flags & METEOR_DEV_MASK;
+		break;
+
+	case METEORSACTPIXFMT:
+		if (( *(int *)arg < 0 ) ||
+		    ( *(int *)arg >= PIXFMT_TABLE_SIZE ))
+			return( EINVAL );
+
+		bktr->pixfmt          = *(int *)arg;
+		OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
+		     | pixfmt_swap_flags( bktr->pixfmt ));
+		bktr->pixfmt_compat   = FALSE;
+		break;
+	
+	case METEORGACTPIXFMT:
+		*(int *)arg = bktr->pixfmt;
+		break;
+
+	case METEORGSUPPIXFMT :
+		pf_pub = (struct meteor_pixfmt *)arg;
+		pixfmt = pf_pub->index;
+
+		if (( pixfmt < 0 ) || ( pixfmt >= PIXFMT_TABLE_SIZE ))
+			return( EINVAL );
+
+		memcpy( pf_pub, &pixfmt_table[ pixfmt ].public, 
+			sizeof( *pf_pub ) );
+
+		/*  Patch in our format index  */
+		pf_pub->index       = pixfmt;
+		break;
+
+#if defined( STATUS_SUM )
+	case BT848_GSTATUS:	/* reap status */
+		{
+                DECLARE_INTR_MASK(s);
+		DISABLE_INTR(s);
+		temp = status_sum;
+		status_sum = 0;
+		ENABLE_INTR(s);
+		*(u_int*)arg = temp;
+		break;
+		}
+#endif /* STATUS_SUM */
+
+	default:
+		return( ENOTTY );
+	}
+
+	return( 0 );
+}
+
+
+
+
+/******************************************************************************
+ * bt848 RISC programming routines:
+ */
+
+
+/*
+ * 
+ */
+#ifdef BT848_DEBUG 
+static int
+dump_bt848( bktr_ptr_t bktr )
+{
+	int	r[60]={
+			   4,    8, 0xc, 0x8c, 0x10, 0x90, 0x14, 0x94, 
+			0x18, 0x98, 0x1c, 0x9c, 0x20, 0xa0, 0x24, 0xa4,
+			0x28, 0x2c, 0xac, 0x30, 0x34, 0x38, 0x3c, 0x40,
+			0xc0, 0x48, 0x4c, 0xcc, 0x50, 0xd0, 0xd4, 0x60,
+			0x64, 0x68, 0x6c, 0xec, 0xd8, 0xdc, 0xe0, 0xe4,
+			0,	 0,    0,    0
+		   };
+	int	i;
+
+	for (i = 0; i < 40; i+=4) {
+		printf("%s: Reg:value : \t%x:%x \t%x:%x \t %x:%x \t %x:%x\n",
+		       bktr_name(bktr), 
+		       r[i], INL(bktr, r[i]),
+		       r[i+1], INL(bktr, r[i+1]),
+		       r[i+2], INL(bktr, r[i+2]),
+		       r[i+3], INL(bktr, r[i+3]]));
+	}
+
+	printf("%s: INT STAT %x \n", bktr_name(bktr),
+	       INL(bktr, BKTR_INT_STAT)); 
+	printf("%s: Reg INT_MASK %x \n", bktr_name(bktr),
+	       INL(bktr, BKTR_INT_MASK));
+	printf("%s: Reg GPIO_DMA_CTL %x \n", bktr_name(bktr),
+	       INW(bktr, BKTR_GPIO_DMA_CTL));
+
+	return( 0 );
+}
+
+#endif
+
+/*
+ * build write instruction
+ */
+#define BKTR_FM1      0x6	/* packed data to follow */
+#define BKTR_FM3      0xe	/* planar data to follow */
+#define BKTR_VRE      0x4	/* Marks the end of the even field */
+#define BKTR_VRO      0xC	/* Marks the end of the odd field */
+#define BKTR_PXV      0x0	/* valid word (never used) */
+#define BKTR_EOL      0x1	/* last dword, 4 bytes */
+#define BKTR_SOL      0x2	/* first dword */
+
+#define OP_WRITE      (0x1 << 28)
+#define OP_SKIP       (0x2 << 28)
+#define OP_WRITEC     (0x5 << 28)
+#define OP_JUMP	      (0x7 << 28)
+#define OP_SYNC	      (0x8 << 28)
+#define OP_WRITE123   (0x9 << 28)
+#define OP_WRITES123  (0xb << 28)
+#define OP_SOL	      (1 << 27)		/* first instr for scanline */
+#define OP_EOL	      (1 << 26)
+
+#define BKTR_RESYNC   (1 << 15)
+#define BKTR_GEN_IRQ  (1 << 24)
+
+/*
+ * The RISC status bits can be set/cleared in the RISC programs
+ * and tested in the Interrupt Handler
+ */
+#define BKTR_SET_RISC_STATUS_BIT0 (1 << 16)
+#define BKTR_SET_RISC_STATUS_BIT1 (1 << 17)
+#define BKTR_SET_RISC_STATUS_BIT2 (1 << 18)
+#define BKTR_SET_RISC_STATUS_BIT3 (1 << 19)
+
+#define BKTR_CLEAR_RISC_STATUS_BIT0 (1 << 20)
+#define BKTR_CLEAR_RISC_STATUS_BIT1 (1 << 21)
+#define BKTR_CLEAR_RISC_STATUS_BIT2 (1 << 22)
+#define BKTR_CLEAR_RISC_STATUS_BIT3 (1 << 23)
+
+#define BKTR_TEST_RISC_STATUS_BIT0 (1 << 28)
+#define BKTR_TEST_RISC_STATUS_BIT1 (1 << 29)
+#define BKTR_TEST_RISC_STATUS_BIT2 (1 << 30)
+#define BKTR_TEST_RISC_STATUS_BIT3 (1 << 31)
+
+bool_t notclipped (bktr_reg_t * bktr, int x, int width) {
+    int i;
+    bktr_clip_t * clip_node;
+    bktr->clip_start = -1;
+    bktr->last_y = 0;
+    bktr->y = 0;
+    bktr->y2 = width;
+    bktr->line_length = width;
+    bktr->yclip = -1;
+    bktr->yclip2 = -1;
+    bktr->current_col = 0;
+    
+    if (bktr->max_clip_node == 0 ) return TRUE;
+    clip_node = (bktr_clip_t *) &bktr->clip_list[0];
+
+
+    for (i = 0; i < bktr->max_clip_node; i++ ) {
+	clip_node = (bktr_clip_t *) &bktr->clip_list[i];
+	if (x >= clip_node->x_min && x <= clip_node->x_max  ) {
+	    bktr->clip_start = i;
+	    return FALSE;
+	}
+    }	
+    
+    return TRUE;
+}	
+
+bool_t getline(bktr_reg_t *bktr, int x ) {
+    int i, j;
+    bktr_clip_t * clip_node ;
+    
+    if (bktr->line_length == 0 || 
+	bktr->current_col >= bktr->line_length) return FALSE;
+
+    bktr->y = min(bktr->last_y, bktr->line_length);
+    bktr->y2 = bktr->line_length;
+
+    bktr->yclip = bktr->yclip2 = -1;
+    for (i = bktr->clip_start; i < bktr->max_clip_node; i++ ) {
+	clip_node = (bktr_clip_t *) &bktr->clip_list[i];
+	if (x >= clip_node->x_min && x <= clip_node->x_max) {
+	    if (bktr->last_y <= clip_node->y_min) {
+		bktr->y =      min(bktr->last_y, bktr->line_length);
+		bktr->y2 =     min(clip_node->y_min, bktr->line_length);
+		bktr->yclip =  min(clip_node->y_min, bktr->line_length);
+		bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
+		bktr->last_y = bktr->yclip2;
+		bktr->clip_start = i;
+		
+		for (j = i+1; j  < bktr->max_clip_node; j++ ) {
+		    clip_node = (bktr_clip_t *) &bktr->clip_list[j];
+		    if (x >= clip_node->x_min && x <= clip_node->x_max) {
+			if (bktr->last_y >= clip_node->y_min) {
+			    bktr->yclip2 = min(clip_node->y_max, bktr->line_length);
+			    bktr->last_y = bktr->yclip2;
+			    bktr->clip_start = j;
+			}	
+		    } else break  ;
+		}	
+		return TRUE;
+	    }	
+	}
+    }
+
+    if (bktr->current_col <= bktr->line_length) {
+	bktr->current_col = bktr->line_length;
+	return TRUE;
+    }
+    return FALSE;
+}
+    
+static bool_t split(bktr_reg_t * bktr, volatile u_long **dma_prog, int width ,
+		    u_long operation, int pixel_width,
+		    volatile u_char ** target_buffer, int cols ) {
+
+ u_long flag, flag2;
+ struct meteor_pixfmt *pf = &pixfmt_table[ bktr->pixfmt ].public;
+ u_int  skip, start_skip;
+
+  /*  For RGB24, we need to align the component in FIFO Byte Lane 0         */
+  /*    to the 1st byte in the mem dword containing our start addr.         */
+  /*    BTW, we know this pixfmt's 1st byte is Blue; thus the start addr    */
+  /*     must be Blue.                                                      */
+  start_skip = 0;
+  if (( pf->type == METEOR_PIXTYPE_RGB ) && ( pf->Bpp == 3 ))
+	  switch ( ((uintptr_t) (volatile void *) *target_buffer) % 4 ) {
+	  case 2 : start_skip = 4 ; break;
+	  case 1 : start_skip = 8 ; break;
+	  }
+
+ if ((width * pixel_width) < DMA_BT848_SPLIT ) {
+     if (  width == cols) {
+	 flag = OP_SOL | OP_EOL;
+       } else if (bktr->current_col == 0 ) {
+	    flag  = OP_SOL;
+       } else if (bktr->current_col == cols) {
+	    flag = OP_EOL;
+       } else flag = 0;	
+
+     skip = 0;
+     if (( flag & OP_SOL ) && ( start_skip > 0 )) {
+	     *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip;
+	     flag &= ~OP_SOL;
+	     skip = start_skip;
+     }
+
+     *(*dma_prog)++ = operation | flag  | (width * pixel_width - skip);
+     if (operation != OP_SKIP ) 
+	 *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer;
+
+     *target_buffer += width * pixel_width;
+     bktr->current_col += width;
+
+ } else {
+
+	if (bktr->current_col == 0 && width == cols) {
+	    flag = OP_SOL ;
+	    flag2 = OP_EOL;
+        } else if (bktr->current_col == 0 ) {
+	    flag = OP_SOL;
+	    flag2 = 0;
+	} else if (bktr->current_col >= cols)  {
+	    flag =  0;
+	    flag2 = OP_EOL;
+	} else {
+	    flag =  0;
+	    flag2 = 0;
+	}
+
+	skip = 0;
+	if (( flag & OP_SOL ) && ( start_skip > 0 )) {
+		*(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip;
+		flag &= ~OP_SOL;
+		skip = start_skip;
+	}
+
+	*(*dma_prog)++ = operation  | flag |
+	      (width * pixel_width / 2 - skip);
+	if (operation != OP_SKIP ) 
+	      *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer ;
+	*target_buffer +=  (width * pixel_width / 2) ;
+
+	if ( operation == OP_WRITE )
+		operation = OP_WRITEC;
+	*(*dma_prog)++ = operation | flag2 |
+	    (width * pixel_width / 2);
+	*target_buffer +=  (width * pixel_width / 2) ;
+	  bktr->current_col += width;
+
+    }
+ return TRUE;
+}
+
+
+/*
+ * Generate the RISC instructions to capture both VBI and video images
+ */
+static void
+rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
+{
+	int			i;
+	volatile u_long		target_buffer, buffer, target,width;
+	volatile u_long		pitch;
+	volatile u_long		*dma_prog;	/* DMA prog is an array of 
+						32 bit RISC instructions */
+	volatile u_long		*loop_point;
+        struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
+	u_int                   Bpp = pf_int->public.Bpp;
+	unsigned int            vbisamples;     /* VBI samples per line */
+	unsigned int            vbilines;       /* VBI lines per field */
+	unsigned int            num_dwords;     /* DWORDS per line */
+
+	vbisamples = format_params[bktr->format_params].vbi_num_samples;
+	vbilines   = format_params[bktr->format_params].vbi_num_lines;
+	num_dwords = vbisamples/4;
+
+	OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
+	OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
+	OUTB(bktr, BKTR_VBI_PACK_SIZE, ((num_dwords)) & 0xff);
+	OUTB(bktr, BKTR_VBI_PACK_DEL, ((num_dwords)>> 8) & 0x01); /* no hdelay    */
+							    /* no ext frame */
+
+	OUTB(bktr, BKTR_OFORM, 0x00);
+
+ 	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
+ 	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
+	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
+	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
+
+ 	/* disable gamma correction removal */
+ 	OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
+
+	if (cols > 385 ) {
+	    OUTB(bktr, BKTR_E_VTC, 0);
+	    OUTB(bktr, BKTR_O_VTC, 0);
+	} else {
+	    OUTB(bktr, BKTR_E_VTC, 1);
+	    OUTB(bktr, BKTR_O_VTC, 1);
+	}
+	bktr->capcontrol = 3 << 2 |  3;
+
+	dma_prog = (u_long *) bktr->dma_prog;
+
+	/* Construct Write */
+
+	if (bktr->video.addr) {
+		target_buffer = (u_long) bktr->video.addr;
+		pitch = bktr->video.width;
+	}
+	else {
+		target_buffer = (u_long) vtophys(bktr->bigbuf);
+		pitch = cols*Bpp;
+	}
+
+	buffer = target_buffer;
+
+	/* Wait for the VRE sync marking the end of the Even and
+	 * the start of the Odd field. Resync here.
+	 */
+	*dma_prog++ = OP_SYNC | BKTR_RESYNC |BKTR_VRE;
+	*dma_prog++ = 0;
+
+	loop_point = dma_prog;
+
+	/* store the VBI data */
+	/* look for sync with packed data */
+	*dma_prog++ = OP_SYNC | BKTR_FM1;
+	*dma_prog++ = 0;
+	for(i = 0; i < vbilines; i++) {
+		*dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples;
+		*dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
+					(i * VBI_LINE_SIZE));
+	}
+
+	if ( (i_flag == 2/*Odd*/) || (i_flag==3) /*interlaced*/ ) { 
+		/* store the Odd field video image */
+		/* look for sync with packed data */
+		*dma_prog++ = OP_SYNC  | BKTR_FM1;
+		*dma_prog++ = 0;  /* NULL WORD */
+		width = cols;
+		for (i = 0; i < (rows/interlace); i++) {
+		    target = target_buffer;
+		    if ( notclipped(bktr, i, width)) {
+			split(bktr, (volatile u_long **) &dma_prog,
+			      bktr->y2 - bktr->y, OP_WRITE,
+			      Bpp, (volatile u_char **) &target,  cols);
+	
+		    } else {
+			while(getline(bktr, i)) {
+			    if (bktr->y != bktr->y2 ) {
+				split(bktr, (volatile u_long **) &dma_prog,
+				      bktr->y2 - bktr->y, OP_WRITE,
+				      Bpp, (volatile u_char **) &target, cols);
+			    }
+			    if (bktr->yclip != bktr->yclip2 ) {
+				split(bktr,(volatile u_long **) &dma_prog,
+				      bktr->yclip2 - bktr->yclip,
+				      OP_SKIP,
+				      Bpp, (volatile u_char **) &target,  cols);
+			    }
+			}
+			
+		    }
+	
+		    target_buffer += interlace * pitch;
+	
+		}
+
+	} /* end if */
+
+	/* Grab the Even field */
+	/* Look for the VRO, end of Odd field, marker */
+	*dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
+	*dma_prog++ = 0;  /* NULL WORD */
+
+	/* store the VBI data */
+	/* look for sync with packed data */
+	*dma_prog++ = OP_SYNC | BKTR_FM1;
+	*dma_prog++ = 0;
+	for(i = 0; i < vbilines; i++) {
+		*dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples;
+		*dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata +
+				((i+MAX_VBI_LINES) * VBI_LINE_SIZE));
+	}
+
+	/* store the video image */
+	if (i_flag == 1) /*Even Only*/
+	        target_buffer = buffer;
+	if (i_flag == 3) /*interlaced*/
+	        target_buffer = buffer+pitch;
+
+
+	if ((i_flag == 1) /*Even Only*/ || (i_flag==3) /*interlaced*/) {
+		/* look for sync with packed data */
+		*dma_prog++ = OP_SYNC | BKTR_FM1;
+		*dma_prog++ = 0;  /* NULL WORD */
+		width = cols;
+		for (i = 0; i < (rows/interlace); i++) {
+		    target = target_buffer;
+		    if ( notclipped(bktr, i, width)) {
+			split(bktr, (volatile u_long **) &dma_prog,
+			      bktr->y2 - bktr->y, OP_WRITE,
+			      Bpp, (volatile u_char **) &target,  cols);
+		    } else {
+			while(getline(bktr, i)) {
+			    if (bktr->y != bktr->y2 ) {
+				split(bktr, (volatile u_long **) &dma_prog,
+				      bktr->y2 - bktr->y, OP_WRITE,
+				      Bpp, (volatile u_char **) &target,
+				      cols);
+			    }	
+			    if (bktr->yclip != bktr->yclip2 ) {
+				split(bktr, (volatile u_long **) &dma_prog,
+				      bktr->yclip2 - bktr->yclip, OP_SKIP,
+				      Bpp, (volatile u_char **)  &target,  cols);
+			    }	
+
+			}	
+
+		    }
+
+		    target_buffer += interlace * pitch;
+
+		}
+	}
+
+	/* Look for end of 'Even Field' */
+	*dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE;
+	*dma_prog++ = 0;  /* NULL WORD */
+
+	*dma_prog++ = OP_JUMP ;
+	*dma_prog++ = (u_long ) vtophys(loop_point) ;
+	*dma_prog++ = 0;  /* NULL WORD */
+
+}
+
+
+
+
+static void
+rgb_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace )
+{
+	int			i;
+	volatile u_long		target_buffer, buffer, target,width;
+	volatile u_long		pitch;
+	volatile  u_long	*dma_prog;
+        struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
+	u_int                   Bpp = pf_int->public.Bpp;
+
+	OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
+	OUTB(bktr, BKTR_VBI_PACK_SIZE, 0);
+	OUTB(bktr, BKTR_VBI_PACK_DEL, 0);
+	OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
+
+	OUTB(bktr, BKTR_OFORM, 0x00);
+
+ 	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */
+ 	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40);
+	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
+	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
+
+ 	/* disable gamma correction removal */
+	OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
+
+	if (cols > 385 ) {
+	    OUTB(bktr, BKTR_E_VTC, 0);
+	    OUTB(bktr, BKTR_O_VTC, 0);
+	} else {
+	    OUTB(bktr, BKTR_E_VTC, 1);
+	    OUTB(bktr, BKTR_O_VTC, 1);
+	}
+	bktr->capcontrol = 3 << 2 |  3;
+
+	dma_prog = (u_long *) bktr->dma_prog;
+
+	/* Construct Write */
+
+	if (bktr->video.addr) {
+		target_buffer = (u_long) bktr->video.addr;
+		pitch = bktr->video.width;
+	}
+	else {
+		target_buffer = (u_long) vtophys(bktr->bigbuf);
+		pitch = cols*Bpp;
+	}
+
+	buffer = target_buffer;
+
+	/* contruct sync : for video packet format */
+	*dma_prog++ = OP_SYNC  | BKTR_RESYNC | BKTR_FM1;
+
+	/* sync, mode indicator packed data */
+	*dma_prog++ = 0;  /* NULL WORD */
+	width = cols;
+	for (i = 0; i < (rows/interlace); i++) {
+	    target = target_buffer;
+	    if ( notclipped(bktr, i, width)) {
+		split(bktr, (volatile u_long **) &dma_prog,
+		      bktr->y2 - bktr->y, OP_WRITE,
+		      Bpp, (volatile u_char **) &target,  cols);
+
+	    } else {
+		while(getline(bktr, i)) {
+		    if (bktr->y != bktr->y2 ) {
+			split(bktr, (volatile u_long **) &dma_prog,
+			      bktr->y2 - bktr->y, OP_WRITE,
+			      Bpp, (volatile u_char **) &target, cols);
+		    }
+		    if (bktr->yclip != bktr->yclip2 ) {
+			split(bktr,(volatile u_long **) &dma_prog,
+			      bktr->yclip2 - bktr->yclip,
+			      OP_SKIP,
+			      Bpp, (volatile u_char **) &target,  cols);
+		    }
+		}
+
+	    }
+
+	    target_buffer += interlace * pitch;
+
+	}
+
+	switch (i_flag) {
+	case 1:
+		/* sync vre */
+		*dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO;
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+		return;
+
+	case 2:
+		/* sync vro */
+		*dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE;
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+		return;
+
+	case 3:
+		/* sync vro */
+		*dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO;
+		*dma_prog++ = 0;  /* NULL WORD */
+		*dma_prog++ = OP_JUMP; ;
+		*dma_prog = (u_long ) vtophys(bktr->odd_dma_prog);
+		break;
+	}
+
+	if (interlace == 2) {
+
+	        target_buffer = buffer + pitch; 
+
+		dma_prog = (u_long *) bktr->odd_dma_prog;
+
+		/* sync vre IRQ bit */
+		*dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1;
+		*dma_prog++ = 0;  /* NULL WORD */
+                width = cols;
+		for (i = 0; i < (rows/interlace); i++) {
+		    target = target_buffer;
+		    if ( notclipped(bktr, i, width)) {
+			split(bktr, (volatile u_long **) &dma_prog,
+			      bktr->y2 - bktr->y, OP_WRITE,
+			      Bpp, (volatile u_char **) &target,  cols);
+		    } else {
+			while(getline(bktr, i)) {
+			    if (bktr->y != bktr->y2 ) {
+				split(bktr, (volatile u_long **) &dma_prog,
+				      bktr->y2 - bktr->y, OP_WRITE,
+				      Bpp, (volatile u_char **) &target,
+				      cols);
+			    }	
+			    if (bktr->yclip != bktr->yclip2 ) {
+				split(bktr, (volatile u_long **) &dma_prog,
+				      bktr->yclip2 - bktr->yclip, OP_SKIP,
+				      Bpp, (volatile u_char **)  &target,  cols);
+			    }	
+
+			}	
+
+		    }
+
+		    target_buffer += interlace * pitch;
+
+		}
+	}
+
+	/* sync vre IRQ bit */
+	*dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE;
+	*dma_prog++ = 0;  /* NULL WORD */
+	*dma_prog++ = OP_JUMP ;
+	*dma_prog++ = (u_long ) vtophys(bktr->dma_prog) ;
+	*dma_prog++ = 0;  /* NULL WORD */
+}
+
+
+/*
+ * 
+ */
+static void
+yuvpack_prog( bktr_ptr_t bktr, char i_flag,
+	      int cols, int rows, int interlace )
+{
+	int			i;
+	volatile unsigned int	inst;
+	volatile unsigned int	inst3;
+	volatile u_long		target_buffer, buffer;
+	volatile  u_long	*dma_prog;
+        struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
+	int			b;
+
+	OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
+
+	OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* enable chroma comb */
+	OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
+
+	OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_RGB_DED | BT848_COLOR_CTL_GAMMA);
+	OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
+
+	bktr->capcontrol =   1 << 6 | 1 << 4 | 1 << 2 | 3;
+	bktr->capcontrol = 3 << 2 |  3;
+
+	dma_prog = (u_long *) bktr->dma_prog;
+
+	/* Construct Write */
+    
+	/* write , sol, eol */
+	inst = OP_WRITE	 | OP_SOL | (cols);
+	/* write , sol, eol */
+	inst3 = OP_WRITE | OP_EOL | (cols);
+
+	if (bktr->video.addr)
+		target_buffer = (u_long) bktr->video.addr;
+	else
+		target_buffer = (u_long) vtophys(bktr->bigbuf);
+
+	buffer = target_buffer;
+
+	/* contruct sync : for video packet format */
+	/* sync, mode indicator packed data */
+	*dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM1;
+	*dma_prog++ = 0;  /* NULL WORD */
+
+	b = cols;
+
+	for (i = 0; i < (rows/interlace); i++) {
+		*dma_prog++ = inst;
+		*dma_prog++ = target_buffer;
+		*dma_prog++ = inst3;
+		*dma_prog++ = target_buffer + b; 
+		target_buffer += interlace*(cols * 2);
+	}
+
+	switch (i_flag) {
+	case 1:
+		/* sync vre */
+		*dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRE;
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+		return;
+
+	case 2:
+		/* sync vro */
+		*dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRO;
+		*dma_prog++ = 0;  /* NULL WORD */
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+		return;
+
+	case 3:
+		/* sync vro */
+		*dma_prog++ = OP_SYNC	 | 1 << 24 | 1 << 15 | BKTR_VRO;
+		*dma_prog++ = 0;  /* NULL WORD */
+		*dma_prog++ = OP_JUMP  ;
+		*dma_prog = (u_long ) vtophys(bktr->odd_dma_prog);
+		break;
+	}
+
+	if (interlace == 2) {
+
+		target_buffer =	 (u_long) buffer + cols*2;
+
+		dma_prog = (u_long * ) bktr->odd_dma_prog;
+
+		/* sync vre */
+		*dma_prog++ = OP_SYNC | 1 << 24 |  1 << 15 | BKTR_FM1;
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		for (i = 0; i < (rows/interlace) ; i++) {
+			*dma_prog++ = inst;
+			*dma_prog++ = target_buffer;
+			*dma_prog++ = inst3;
+			*dma_prog++ = target_buffer + b;
+			target_buffer += interlace * ( cols*2);
+		}
+	}
+
+	/* sync vro IRQ bit */
+	*dma_prog++ = OP_SYNC   |  1 << 24  | 1 << 15 |  BKTR_VRE;
+	*dma_prog++ = 0;  /* NULL WORD */
+	*dma_prog++ = OP_JUMP ;
+	*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+
+	*dma_prog++ = OP_JUMP;
+	*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+	*dma_prog++ = 0;  /* NULL WORD */
+}
+
+
+/*
+ * 
+ */
+static void
+yuv422_prog( bktr_ptr_t bktr, char i_flag,
+	     int cols, int rows, int interlace ){
+
+	int			i;
+	volatile unsigned int	inst;
+	volatile u_long		target_buffer, t1, buffer;
+	volatile u_long		*dma_prog;
+        struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
+
+	OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
+
+	dma_prog = (u_long *) bktr->dma_prog;
+
+	bktr->capcontrol =   1 << 6 | 1 << 4 |	3;
+
+	OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
+	OUTB(bktr, BKTR_OFORM, 0x00);
+
+	OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_LDEC); /* disable luma decimation */
+	OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_LDEC);
+
+	OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC);	/* chroma agc enable */
+	OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC);
+
+	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */
+	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80);
+	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | ~0x40); /* set chroma comb */
+	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | ~0x40);
+
+	/* disable gamma correction removal */
+	OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA);
+
+	/* Construct Write */
+	inst  = OP_WRITE123  | OP_SOL | OP_EOL |  (cols); 
+	if (bktr->video.addr)
+		target_buffer = (u_long) bktr->video.addr;
+	else
+		target_buffer = (u_long) vtophys(bktr->bigbuf);
+    
+	buffer = target_buffer;
+
+	t1 = buffer;
+
+	/* contruct sync : for video packet format */
+	*dma_prog++ = OP_SYNC  | 1 << 15 |	BKTR_FM3; /*sync, mode indicator packed data*/
+	*dma_prog++ = 0;  /* NULL WORD */
+
+	for (i = 0; i < (rows/interlace ) ; i++) {
+		*dma_prog++ = inst;
+		*dma_prog++ = cols/2 | cols/2 << 16;
+		*dma_prog++ = target_buffer;
+		*dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
+		*dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace;
+		target_buffer += interlace*cols;
+	}
+
+	switch (i_flag) {
+	case 1:
+		*dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRE;  /*sync vre*/
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP ;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+		return;
+
+	case 2:
+		*dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRO;  /*sync vre*/
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+		return;
+
+	case 3:
+		*dma_prog++ = OP_SYNC	| 1 << 24 |  1 << 15 |   BKTR_VRO; 
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP  ;
+		*dma_prog = (u_long ) vtophys(bktr->odd_dma_prog);
+		break;
+	}
+
+	if (interlace == 2) {
+
+		dma_prog = (u_long * ) bktr->odd_dma_prog;
+
+		target_buffer  = (u_long) buffer + cols;
+		t1 = buffer + cols/2;
+		*dma_prog++ = OP_SYNC	|   1 << 15 | BKTR_FM3; 
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		for (i = 0; i < (rows/interlace )  ; i++) {
+			*dma_prog++ = inst;
+			*dma_prog++ = cols/2 | cols/2 << 16;
+			*dma_prog++ = target_buffer;
+			*dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
+			*dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace;
+			target_buffer += interlace*cols;
+		}
+	}
+    
+	*dma_prog++ = OP_SYNC  | 1 << 24 | 1 << 15 |   BKTR_VRE; 
+	*dma_prog++ = 0;  /* NULL WORD */
+	*dma_prog++ = OP_JUMP ;
+	*dma_prog++ = (u_long ) vtophys(bktr->dma_prog) ;
+	*dma_prog++ = 0;  /* NULL WORD */
+}
+
+
+/*
+ * 
+ */
+static void
+yuv12_prog( bktr_ptr_t bktr, char i_flag,
+	     int cols, int rows, int interlace ){
+
+	int			i;
+	volatile unsigned int	inst;
+	volatile unsigned int	inst1;
+	volatile u_long		target_buffer, t1, buffer;
+	volatile u_long		*dma_prog;
+        struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
+
+	OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt);
+
+	dma_prog = (u_long *) bktr->dma_prog;
+
+	bktr->capcontrol =   1 << 6 | 1 << 4 |	3;
+
+	OUTB(bktr, BKTR_ADC, SYNC_LEVEL);
+	OUTB(bktr, BKTR_OFORM, 0x0);
+ 
+	/* Construct Write */
+ 	inst  = OP_WRITE123  | OP_SOL | OP_EOL |  (cols); 
+ 	inst1  = OP_WRITES123  | OP_SOL | OP_EOL |  (cols); 
+ 	if (bktr->video.addr)
+ 		target_buffer = (u_long) bktr->video.addr;
+ 	else
+ 		target_buffer = (u_long) vtophys(bktr->bigbuf);
+     
+	buffer = target_buffer;
+ 	t1 = buffer;
+ 
+ 	*dma_prog++ = OP_SYNC  | 1 << 15 |	BKTR_FM3; /*sync, mode indicator packed data*/
+ 	*dma_prog++ = 0;  /* NULL WORD */
+ 	       
+ 	for (i = 0; i < (rows/interlace )/2 ; i++) {
+		*dma_prog++ = inst;
+ 		*dma_prog++ = cols/2 | (cols/2 << 16);
+ 		*dma_prog++ = target_buffer;
+ 		*dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
+ 		*dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace;
+ 		target_buffer += interlace*cols;
+ 		*dma_prog++ = inst1;
+ 		*dma_prog++ = cols/2 | (cols/2 << 16);
+ 		*dma_prog++ = target_buffer;
+ 		target_buffer += interlace*cols;
+ 
+ 	}
+ 
+ 	switch (i_flag) {
+ 	case 1:
+ 		*dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRE;  /*sync vre*/
+ 		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+ 		return;
+
+ 	case 2:
+ 		*dma_prog++ = OP_SYNC  | 1 << 24 | BKTR_VRO;  /*sync vro*/
+ 		*dma_prog++ = 0;  /* NULL WORD */
+
+		*dma_prog++ = OP_JUMP;
+		*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+ 		return;
+ 
+ 	case 3:
+ 		*dma_prog++ = OP_SYNC |  1 << 24 | 1 << 15 | BKTR_VRO;
+		*dma_prog++ = 0;  /* NULL WORD */
+		*dma_prog++ = OP_JUMP ;
+		*dma_prog = (u_long ) vtophys(bktr->odd_dma_prog);
+		break;
+	}
+
+	if (interlace == 2) {
+
+		dma_prog = (u_long * ) bktr->odd_dma_prog;
+
+		target_buffer  = (u_long) buffer + cols;
+		t1 = buffer + cols/2;
+		*dma_prog++ = OP_SYNC   | 1 << 15 | BKTR_FM3; 
+		*dma_prog++ = 0;  /* NULL WORD */
+
+		for (i = 0; i < ((rows/interlace )/2 ) ; i++) {
+		    *dma_prog++ = inst;
+		    *dma_prog++ = cols/2 | (cols/2 << 16);
+         	    *dma_prog++ = target_buffer;
+		    *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace;
+		    *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace;
+		    target_buffer += interlace*cols;
+		    *dma_prog++ = inst1;
+		    *dma_prog++ = cols/2 | (cols/2 << 16);
+		    *dma_prog++ = target_buffer;
+		    target_buffer += interlace*cols;
+
+		}	
+
+	
+	}
+    
+	*dma_prog++ = OP_SYNC |  1 << 24 | 1 << 15 | BKTR_VRE;
+	*dma_prog++ = 0;  /* NULL WORD */
+	*dma_prog++ = OP_JUMP;
+	*dma_prog++ = (u_long ) vtophys(bktr->dma_prog);
+	*dma_prog++ = 0;  /* NULL WORD */
+}
+  
+
+
+/*
+ * 
+ */
+static void
+build_dma_prog( bktr_ptr_t bktr, char i_flag )
+{
+	int			rows, cols,  interlace;
+	int			tmp_int;
+	unsigned int		temp;	
+	struct format_params	*fp;
+        struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ];
+	
+
+	fp = &format_params[bktr->format_params];
+
+	OUTL(bktr, BKTR_INT_MASK,  ALL_INTS_DISABLED);
+
+	/* disable FIFO & RISC, leave other bits alone */
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, INW(bktr, BKTR_GPIO_DMA_CTL) & ~FIFO_RISC_ENABLED);
+
+	/* set video parameters */
+	if (bktr->capture_area_enabled)
+	  temp = ((quad_t ) fp->htotal* (quad_t) bktr->capture_area_x_size * 4096
+		  / fp->scaled_htotal / bktr->cols) -  4096;
+	else
+	  temp = ((quad_t ) fp->htotal* (quad_t) fp->scaled_hactive * 4096
+		  / fp->scaled_htotal / bktr->cols) -  4096;
+
+	/* printf("%s: HSCALE value is %d\n", bktr_name(bktr), temp); */
+	OUTB(bktr, BKTR_E_HSCALE_LO, temp & 0xff);
+	OUTB(bktr, BKTR_O_HSCALE_LO, temp & 0xff);
+	OUTB(bktr, BKTR_E_HSCALE_HI, (temp >> 8) & 0xff);
+	OUTB(bktr, BKTR_O_HSCALE_HI, (temp >> 8) & 0xff);
+ 
+	/* horizontal active */
+	temp = bktr->cols;
+	/* printf("%s: HACTIVE value is %d\n", bktr_name(bktr), temp); */
+	OUTB(bktr, BKTR_E_HACTIVE_LO, temp & 0xff);
+	OUTB(bktr, BKTR_O_HACTIVE_LO, temp & 0xff);
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x3);
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x3);
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 8) & 0x3));
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 8) & 0x3));
+ 
+	/* horizontal delay */
+	if (bktr->capture_area_enabled)
+	  temp = ( (fp->hdelay* fp->scaled_hactive + bktr->capture_area_x_offset* fp->scaled_htotal)
+		 * bktr->cols) / (bktr->capture_area_x_size * fp->hactive);
+	else
+	  temp = (fp->hdelay * bktr->cols) / fp->hactive;
+
+	temp = temp & 0x3fe;
+
+	/* printf("%s: HDELAY value is %d\n", bktr_name(bktr), temp); */
+	OUTB(bktr, BKTR_E_DELAY_LO, temp & 0xff);
+	OUTB(bktr, BKTR_O_DELAY_LO, temp & 0xff);
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xc);
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xc);
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 6) & 0xc));
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 6) & 0xc));
+
+	/* vertical scale */
+
+	if (bktr->capture_area_enabled) {
+	  if (bktr->flags  & METEOR_ONLY_ODD_FIELDS ||
+	      bktr->flags & METEOR_ONLY_EVEN_FIELDS)
+	    tmp_int = 65536 -
+	    (((bktr->capture_area_y_size  * 256 + (bktr->rows/2)) / bktr->rows) - 512);
+	  else {
+	    tmp_int = 65536 -
+	    (((bktr->capture_area_y_size * 512 + (bktr->rows / 2)) /  bktr->rows) - 512);
+	  }
+	} else {
+	  if (bktr->flags  & METEOR_ONLY_ODD_FIELDS ||
+	      bktr->flags & METEOR_ONLY_EVEN_FIELDS)
+	    tmp_int = 65536 -
+	    (((fp->vactive  * 256 + (bktr->rows/2)) / bktr->rows) - 512);
+	  else {
+	    tmp_int = 65536  -
+	    (((fp->vactive * 512 + (bktr->rows / 2)) /  bktr->rows) - 512);
+	  }
+	}
+
+	tmp_int &= 0x1fff;
+	/* printf("%s: VSCALE value is %d\n", bktr_name(bktr), tmp_int); */
+	OUTB(bktr, BKTR_E_VSCALE_LO, tmp_int & 0xff);
+	OUTB(bktr, BKTR_O_VSCALE_LO, tmp_int & 0xff);
+	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x1f);
+	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x1f);
+	OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | ((tmp_int >> 8) & 0x1f));
+	OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | ((tmp_int >> 8) & 0x1f));
+
+
+	/* vertical active */
+	if (bktr->capture_area_enabled)
+	  temp = bktr->capture_area_y_size;
+	else
+	  temp = fp->vactive;
+	/* printf("%s: VACTIVE is %d\n", bktr_name(bktr), temp); */
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x30);
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 4) & 0x30));
+	OUTB(bktr, BKTR_E_VACTIVE_LO, temp & 0xff);
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x30);
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 4) & 0x30));
+	OUTB(bktr, BKTR_O_VACTIVE_LO, temp & 0xff);
+ 
+	/* vertical delay */
+	if (bktr->capture_area_enabled)
+	  temp = fp->vdelay + (bktr->capture_area_y_offset);
+	else
+	  temp = fp->vdelay;
+	/* printf("%s: VDELAY is %d\n", bktr_name(bktr), temp); */
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xC0);
+	OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 2) & 0xC0));
+	OUTB(bktr, BKTR_E_VDELAY_LO, temp & 0xff);
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xC0);
+	OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 2) & 0xC0));
+	OUTB(bktr, BKTR_O_VDELAY_LO, temp & 0xff);
+
+	/* end of video params */
+
+	if ((bktr->xtal_pll_mode == BT848_USE_PLL)
+	   && (fp->iform_xtsel==BT848_IFORM_X_XT1)) {
+		OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_PLL); /* Select PLL mode */
+	} else {
+		OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_XTAL); /* Select Normal xtal 0/xtal 1 mode */
+	}
+
+	/* capture control */
+	switch (i_flag) {
+	case 1:
+	        bktr->bktr_cap_ctl = 
+		    (BT848_CAP_CTL_DITH_FRAME | BT848_CAP_CTL_EVEN);
+		OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20);
+		OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20);
+		interlace = 1;
+		break;
+	 case 2:
+ 	        bktr->bktr_cap_ctl =
+			(BT848_CAP_CTL_DITH_FRAME | BT848_CAP_CTL_ODD);
+		OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20);
+		OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20);
+		interlace = 1;
+		break;
+	 default:
+ 	        bktr->bktr_cap_ctl = 
+			(BT848_CAP_CTL_DITH_FRAME |
+			 BT848_CAP_CTL_EVEN | BT848_CAP_CTL_ODD);
+		OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x20);
+		OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x20);
+		interlace = 2;
+		break;
+	}
+
+	OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
+
+	rows = bktr->rows;
+	cols = bktr->cols;
+
+	bktr->vbiflags &= ~VBI_CAPTURE;	/* default - no vbi capture */
+
+	/* RGB Grabs. If /dev/vbi is already open, or we are a PAL/SECAM */
+	/* user, then use the rgb_vbi RISC program. */
+	/* Otherwise, use the normal rgb RISC program */
+	if (pf_int->public.type == METEOR_PIXTYPE_RGB) {
+		if ( (bktr->vbiflags & VBI_OPEN)
+		   ||(bktr->format_params == BT848_IFORM_F_PALBDGHI)
+		   ||(bktr->format_params == BT848_IFORM_F_SECAM)
+                   ){
+			bktr->bktr_cap_ctl |=
+		                BT848_CAP_CTL_VBI_EVEN | BT848_CAP_CTL_VBI_ODD;
+			bktr->vbiflags |= VBI_CAPTURE;
+			rgb_vbi_prog(bktr, i_flag, cols, rows, interlace);
+			return;
+		} else {
+			rgb_prog(bktr, i_flag, cols, rows, interlace);
+			return;
+		}
+	}
+
+	if ( pf_int->public.type  == METEOR_PIXTYPE_YUV ) {
+		yuv422_prog(bktr, i_flag, cols, rows, interlace);
+		OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
+		     | pixfmt_swap_flags( bktr->pixfmt ));
+		return;
+	}
+
+	if ( pf_int->public.type  == METEOR_PIXTYPE_YUV_PACKED ) {
+		yuvpack_prog(bktr, i_flag, cols, rows, interlace);
+		OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
+		     | pixfmt_swap_flags( bktr->pixfmt ));
+		return;
+	}
+
+	if ( pf_int->public.type  == METEOR_PIXTYPE_YUV_12 ) {
+		yuv12_prog(bktr, i_flag, cols, rows, interlace);
+		OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0)
+		     | pixfmt_swap_flags( bktr->pixfmt ));
+		return;
+	}
+	return;
+}
+
+
+/******************************************************************************
+ * video & video capture specific routines:
+ */
+
+
+/*
+ * 
+ */
+static void
+start_capture( bktr_ptr_t bktr, unsigned type )
+{
+	u_char			i_flag;
+	struct format_params   *fp;
+
+	fp = &format_params[bktr->format_params];
+
+	/*  If requested, clear out capture buf first  */
+	if (bktr->clr_on_start && (bktr->video.addr == 0)) {
+		bzero((caddr_t)bktr->bigbuf, 
+		      (size_t)bktr->rows * bktr->cols * bktr->frames *
+			pixfmt_table[ bktr->pixfmt ].public.Bpp);
+	}
+
+	OUTB(bktr, BKTR_DSTATUS,  0);
+	OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT));
+
+	bktr->flags |= type;
+	bktr->flags &= ~METEOR_WANT_MASK;
+	switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
+	case METEOR_ONLY_EVEN_FIELDS:
+		bktr->flags |= METEOR_WANT_EVEN;
+		i_flag = 1;
+		break;
+	case METEOR_ONLY_ODD_FIELDS:
+		bktr->flags |= METEOR_WANT_ODD;
+		i_flag = 2;
+		break;
+	default:
+		bktr->flags |= METEOR_WANT_MASK;
+		i_flag = 3;
+		break;
+	}
+
+	/*  TDEC is only valid for continuous captures  */
+	if ( type == METEOR_SINGLE ) {
+		u_short	fps_save = bktr->fps;
+
+		set_fps(bktr, fp->frame_rate);
+		bktr->fps = fps_save;
+	}
+	else
+		set_fps(bktr, bktr->fps);
+
+	if (bktr->dma_prog_loaded == FALSE) {
+		build_dma_prog(bktr, i_flag);
+		bktr->dma_prog_loaded = TRUE;
+	}
+	
+
+	OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog));
+
+}
+
+
+/*
+ * 
+ */
+static void
+set_fps( bktr_ptr_t bktr, u_short fps )
+{
+	struct format_params	*fp;
+	int i_flag;
+
+	fp = &format_params[bktr->format_params];
+
+	switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) {
+	case METEOR_ONLY_EVEN_FIELDS:
+		bktr->flags |= METEOR_WANT_EVEN;
+		i_flag = 1;
+		break;
+	case METEOR_ONLY_ODD_FIELDS:
+		bktr->flags |= METEOR_WANT_ODD;
+		i_flag = 1;
+		break;
+	default:
+		bktr->flags |= METEOR_WANT_MASK;
+		i_flag = 2;
+		break;
+	}
+
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+	OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED);
+
+	bktr->fps = fps;
+	OUTB(bktr, BKTR_TDEC, 0);
+
+	if (fps < fp->frame_rate)
+		OUTB(bktr, BKTR_TDEC, i_flag*(fp->frame_rate - fps) & 0x3f);
+	else
+		OUTB(bktr, BKTR_TDEC, 0);
+	return;
+
+}
+
+
+
+
+
+/* 
+ * Given a pixfmt index, compute the bt848 swap_flags necessary to 
+ *   achieve the specified swapping.
+ * Note that without bt swapping, 2Bpp and 3Bpp modes are written 
+ *   byte-swapped, and 4Bpp modes are byte and word swapped (see Table 6 
+ *   and read R->L).  
+ * Note also that for 3Bpp, we may additionally need to do some creative 
+ *   SKIPing to align the FIFO bytelines with the target buffer (see split()).
+ * This is abstracted here: e.g. no swaps = RGBA; byte & short swap = ABGR
+ *   as one would expect.
+ */
+
+static u_int pixfmt_swap_flags( int pixfmt )
+{
+	struct meteor_pixfmt *pf = &pixfmt_table[ pixfmt ].public;
+	u_int		      swapf = 0;
+
+	switch ( pf->Bpp ) {
+	case 2 : swapf = ( pf->swap_bytes ? 0 : BSWAP );
+		 break;
+
+	case 3 : /* no swaps supported for 3bpp - makes no sense w/ bt848 */
+		 break;
+		 
+	case 4 : if ( pf->swap_bytes )
+			swapf = pf->swap_shorts ? 0 : WSWAP;
+		 else
+			swapf = pf->swap_shorts ? BSWAP : (BSWAP | WSWAP);
+		 break;
+	}
+	return swapf;
+}
+
+
+
+/* 
+ * Converts meteor-defined pixel formats (e.g. METEOR_GEO_RGB16) into
+ *   our pixfmt_table indices.
+ */
+
+static int oformat_meteor_to_bt( u_long format )
+{
+	int    i;
+        struct meteor_pixfmt *pf1, *pf2;
+
+	/*  Find format in compatibility table  */
+	for ( i = 0; i < METEOR_PIXFMT_TABLE_SIZE; i++ )
+		if ( meteor_pixfmt_table[i].meteor_format == format )
+			break;
+
+	if ( i >= METEOR_PIXFMT_TABLE_SIZE )
+		return -1;
+	pf1 = &meteor_pixfmt_table[i].public;
+
+	/*  Match it with an entry in master pixel format table  */
+	for ( i = 0; i < PIXFMT_TABLE_SIZE; i++ ) {
+		pf2 = &pixfmt_table[i].public;
+
+		if (( pf1->type        == pf2->type        ) &&
+		    ( pf1->Bpp         == pf2->Bpp         ) &&
+		    !bcmp( pf1->masks, pf2->masks, sizeof( pf1->masks )) &&
+		    ( pf1->swap_bytes  == pf2->swap_bytes  ) &&
+		    ( pf1->swap_shorts == pf2->swap_shorts )) 
+			break;
+	}
+	if ( i >= PIXFMT_TABLE_SIZE )
+		return -1;
+
+	return i;
+}
+
+/******************************************************************************
+ * i2c primitives:
+ */
+
+/* */
+#define I2CBITTIME		(0x5<<4)	/* 5 * 0.48uS */
+#define I2CBITTIME_878              (1 << 7)
+#define I2C_READ		0x01
+#define I2C_COMMAND		(I2CBITTIME |			\
+				 BT848_DATA_CTL_I2CSCL |	\
+				 BT848_DATA_CTL_I2CSDA)
+
+#define I2C_COMMAND_878		(I2CBITTIME_878 |			\
+				 BT848_DATA_CTL_I2CSCL |	\
+				 BT848_DATA_CTL_I2CSDA)
+
+/* Select between old i2c code and new iicbus / smbus code */
+#if defined(BKTR_USE_FREEBSD_SMBUS)
+
+/*
+ * The hardware interface is actually SMB commands
+ */
+int
+i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 )
+{
+	char cmd;
+
+	if (bktr->id == BROOKTREE_848  ||
+	    bktr->id == BROOKTREE_848A ||
+	    bktr->id == BROOKTREE_849A)
+		cmd = I2C_COMMAND;
+	else
+		cmd = I2C_COMMAND_878;
+
+	if (byte2 != -1) {
+		if (smbus_writew(bktr->i2c_sc.smbus, addr, cmd,
+			(short)(((byte2 & 0xff) << 8) | (byte1 & 0xff))))
+			return (-1);
+	} else {
+		if (smbus_writeb(bktr->i2c_sc.smbus, addr, cmd,
+			(char)(byte1 & 0xff)))
+			return (-1);
+	}
+
+	/* return OK */
+	return( 0 );
+}
+
+int
+i2cRead( bktr_ptr_t bktr, int addr )
+{
+	char result;
+	char cmd;
+
+	if (bktr->id == BROOKTREE_848  ||
+	    bktr->id == BROOKTREE_848A ||
+	    bktr->id == BROOKTREE_849A)
+		cmd = I2C_COMMAND;
+	else
+		cmd = I2C_COMMAND_878;
+
+	if (smbus_readb(bktr->i2c_sc.smbus, addr, cmd, &result))
+		return (-1);
+
+	return ((int)((unsigned char)result));
+}
+
+#define IICBUS(bktr) ((bktr)->i2c_sc.iicbus)
+
+/* The MSP34xx and DPL35xx Audio chip require i2c bus writes of up */
+/* to 5 bytes which the bt848 automated i2c bus controller cannot handle */
+/* Therefore we need low level control of the i2c bus hardware */
+
+/* Write to the MSP or DPL registers */
+void
+msp_dpl_write(bktr_ptr_t bktr, int i2c_addr,  unsigned char dev, unsigned int addr, unsigned int data)
+{
+	unsigned char addr_l, addr_h, data_h, data_l ;
+
+	addr_h = (addr >>8) & 0xff;
+	addr_l = addr & 0xff;
+	data_h = (data >>8) & 0xff;
+	data_l = data & 0xff;
+
+	iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
+
+	iicbus_write_byte(IICBUS(bktr), dev, 0);
+	iicbus_write_byte(IICBUS(bktr), addr_h, 0);
+	iicbus_write_byte(IICBUS(bktr), addr_l, 0);
+	iicbus_write_byte(IICBUS(bktr), data_h, 0);
+	iicbus_write_byte(IICBUS(bktr), data_l, 0);
+
+	iicbus_stop(IICBUS(bktr));
+
+	return;
+}
+
+/* Read from the MSP or DPL registers */
+unsigned int
+msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr)
+{
+	unsigned int data;
+	unsigned char addr_l, addr_h, dev_r;
+	int read;
+	u_char data_read[2];
+
+	addr_h = (addr >>8) & 0xff;
+	addr_l = addr & 0xff;
+	dev_r = dev+1;
+
+	/* XXX errors ignored */
+	iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
+
+	iicbus_write_byte(IICBUS(bktr), dev_r, 0);
+	iicbus_write_byte(IICBUS(bktr), addr_h, 0);
+	iicbus_write_byte(IICBUS(bktr), addr_l, 0);
+
+	iicbus_repeated_start(IICBUS(bktr), i2c_addr +1, 0 /* no timeout? */);
+	iicbus_read(IICBUS(bktr), data_read, 2, &read, IIC_LAST_READ, 0);
+	iicbus_stop(IICBUS(bktr));
+
+	data = (data_read[0]<<8) | data_read[1];
+
+	return (data);
+}
+
+/* Reset the MSP or DPL chip */
+/* The user can block the reset (which is handy if you initialise the
+ * MSP and/or DPL audio in another operating system first (eg in Windows)
+ */
+void
+msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr )
+{
+
+#ifndef BKTR_NO_MSP_RESET
+	/* put into reset mode */
+	iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
+	iicbus_write_byte(IICBUS(bktr), 0x00, 0);
+	iicbus_write_byte(IICBUS(bktr), 0x80, 0);
+	iicbus_write_byte(IICBUS(bktr), 0x00, 0);
+	iicbus_stop(IICBUS(bktr));
+
+	/* put back to operational mode */
+	iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */);
+	iicbus_write_byte(IICBUS(bktr), 0x00, 0);
+	iicbus_write_byte(IICBUS(bktr), 0x00, 0);
+	iicbus_write_byte(IICBUS(bktr), 0x00, 0);
+	iicbus_stop(IICBUS(bktr));
+#endif
+	return;
+}
+
+static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
+	int read;
+
+	/* XXX errors ignored */
+	iicbus_start(IICBUS(bktr), bktr->remote_control_addr, 0 /* no timeout? */);
+	iicbus_read(IICBUS(bktr),  remote->data, 3, &read, IIC_LAST_READ, 0);
+	iicbus_stop(IICBUS(bktr));
+
+	return;
+}
+
+#else /* defined(BKTR_USE_FREEBSD_SMBUS) */
+
+/*
+ * Program the i2c bus directly
+ */
+int
+i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 )
+{
+	u_long		x;
+	u_long		data;
+
+	/* clear status bits */
+	OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
+
+	/* build the command datum */
+	if (bktr->id == BROOKTREE_848  ||
+	    bktr->id == BROOKTREE_848A ||
+	    bktr->id == BROOKTREE_849A) {
+	  data = ((addr & 0xff) << 24) | ((byte1 & 0xff) << 16) | I2C_COMMAND;
+	} else {
+	  data = ((addr & 0xff) << 24) | ((byte1 & 0xff) << 16) | I2C_COMMAND_878;
+	}
+	if ( byte2 != -1 ) {
+		data |= ((byte2 & 0xff) << 8);
+		data |= BT848_DATA_CTL_I2CW3B;
+	}
+
+	/* write the address and data */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, data);
+
+	/* wait for completion */
+	for ( x = 0x7fffffff; x; --x ) {	/* safety valve */
+		if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE )
+			break;
+	}
+
+	/* check for ACK */
+	if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) )
+		return( -1 );
+
+	/* return OK */
+	return( 0 );
+}
+
+
+/*
+ * 
+ */
+int
+i2cRead( bktr_ptr_t bktr, int addr )
+{
+	u_long		x;
+
+	/* clear status bits */
+	OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE);
+
+	/* write the READ address */
+	/* The Bt878 and Bt879  differed on the treatment of i2c commands */
+	   
+	if (bktr->id == BROOKTREE_848  ||
+	    bktr->id == BROOKTREE_848A ||
+	    bktr->id == BROOKTREE_849A) {
+		OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND);
+	} else {
+		OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND_878);
+	}
+
+	/* wait for completion */
+	for ( x = 0x7fffffff; x; --x ) {	/* safety valve */
+		if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE )
+			break;
+	}
+
+	/* check for ACK */
+	if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) )
+		return( -1 );
+
+	/* it was a read */
+	return( (INL(bktr, BKTR_I2C_DATA_CTL) >> 8) & 0xff );
+}
+
+/* The MSP34xx Audio chip require i2c bus writes of up to 5 bytes which the */
+/* bt848 automated i2c bus controller cannot handle */
+/* Therefore we need low level control of the i2c bus hardware */
+/* Idea for the following functions are from elsewhere in this driver and */
+/* from the Linux BTTV i2c driver by Gerd Knorr <kraxel@cs.tu-berlin.de> */
+
+#define BITD    40
+static void i2c_start( bktr_ptr_t bktr) {
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release data */
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release clock */
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* lower data */
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock */
+}
+
+static void i2c_stop( bktr_ptr_t bktr) {
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock & data */
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* release clock */
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release data */
+}
+
+static int i2c_write_byte( bktr_ptr_t bktr, unsigned char data) {
+        int x;
+        int status;
+
+        /* write out the byte */
+        for ( x = 7; x >= 0; --x ) {
+                if ( data & (1<<x) ) {
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+                        DELAY( BITD );          /* assert HI data */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
+                        DELAY( BITD );          /* strobe clock */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+                        DELAY( BITD );          /* release clock */
+                }
+                else {
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
+                        DELAY( BITD );          /* assert LO data */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
+                        DELAY( BITD );          /* strobe clock */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
+                        DELAY( BITD );          /* release clock */
+                }
+        }
+
+        /* look for an ACK */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* float data */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* strobe clock */
+        status = INL(bktr, BKTR_I2C_DATA_CTL) & 1;       /* read the ACK bit */
+        OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release clock */
+
+        return( status );
+}
+
+static int i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last ) {
+        int x;
+        int bit;
+        int byte = 0;
+
+        /* read in the byte */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+        DELAY( BITD );                          /* float data */
+        for ( x = 7; x >= 0; --x ) {
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
+                DELAY( BITD );                  /* strobe clock */
+                bit = INL(bktr, BKTR_I2C_DATA_CTL) & 1;  /* read the data bit */
+                if ( bit ) byte |= (1<<x);
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+                DELAY( BITD );                  /* release clock */
+        }
+        /* After reading the byte, send an ACK */
+        /* (unless that was the last byte, for which we send a NAK */
+        if (last) { /* send NAK - same a writing a 1 */
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+                DELAY( BITD );                  /* set data bit */
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
+                DELAY( BITD );                  /* strobe clock */
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+                DELAY( BITD );                  /* release clock */
+        } else { /* send ACK - same as writing a 0 */
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
+                DELAY( BITD );                  /* set data bit */
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
+                DELAY( BITD );                  /* strobe clock */
+		OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
+                DELAY( BITD );                  /* release clock */
+        }
+
+        *data=byte;
+	return 0;
+}
+#undef BITD
+
+/* Write to the MSP or DPL registers */
+void msp_dpl_write( bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr,
+		    unsigned int data){
+	unsigned int msp_w_addr = i2c_addr;
+	unsigned char addr_l, addr_h, data_h, data_l ;
+	addr_h = (addr >>8) & 0xff;
+	addr_l = addr & 0xff;
+	data_h = (data >>8) & 0xff;
+	data_l = data & 0xff;
+
+	i2c_start(bktr);
+	i2c_write_byte(bktr, msp_w_addr);
+	i2c_write_byte(bktr, dev);
+	i2c_write_byte(bktr, addr_h);
+	i2c_write_byte(bktr, addr_l);
+	i2c_write_byte(bktr, data_h);
+	i2c_write_byte(bktr, data_l);
+	i2c_stop(bktr);
+}
+
+/* Read from the MSP or DPL registers */
+unsigned int msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr){
+	unsigned int data;
+	unsigned char addr_l, addr_h, data_1, data_2, dev_r ;
+	addr_h = (addr >>8) & 0xff;
+	addr_l = addr & 0xff;
+	dev_r = dev+1;
+
+	i2c_start(bktr);
+	i2c_write_byte(bktr,i2c_addr);
+	i2c_write_byte(bktr,dev_r);
+	i2c_write_byte(bktr,addr_h);
+	i2c_write_byte(bktr,addr_l);
+
+	i2c_start(bktr);
+	i2c_write_byte(bktr,i2c_addr+1);
+	i2c_read_byte(bktr,&data_1, 0);
+	i2c_read_byte(bktr,&data_2, 1);
+	i2c_stop(bktr);
+	data = (data_1<<8) | data_2;
+	return data;
+}
+
+/* Reset the MSP or DPL chip */
+/* The user can block the reset (which is handy if you initialise the
+ * MSP audio in another operating system first (eg in Windows)
+ */
+void msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr ) {
+
+#ifndef BKTR_NO_MSP_RESET
+	/* put into reset mode */
+	i2c_start(bktr);
+	i2c_write_byte(bktr, i2c_addr);
+	i2c_write_byte(bktr, 0x00);
+	i2c_write_byte(bktr, 0x80);
+	i2c_write_byte(bktr, 0x00);
+	i2c_stop(bktr);
+
+	/* put back to operational mode */
+	i2c_start(bktr);
+	i2c_write_byte(bktr, i2c_addr);
+	i2c_write_byte(bktr, 0x00);
+	i2c_write_byte(bktr, 0x00);
+	i2c_write_byte(bktr, 0x00);
+	i2c_stop(bktr);
+#endif
+	return;
+
+}
+
+static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) {
+
+	/* XXX errors ignored */
+	i2c_start(bktr);
+	i2c_write_byte(bktr,bktr->remote_control_addr);
+	i2c_read_byte(bktr,&(remote->data[0]), 0);
+	i2c_read_byte(bktr,&(remote->data[1]), 0);
+	i2c_read_byte(bktr,&(remote->data[2]), 0);
+	i2c_stop(bktr);
+
+	return;
+}
+
+#endif /* defined(BKTR_USE_FREEBSD_SMBUS) */
+
+
+#if defined( I2C_SOFTWARE_PROBE )
+
+/*
+ * we are keeping this around for any parts that we need to probe
+ * but that CANNOT be probed via an i2c read.
+ * this is necessary because the hardware i2c mechanism
+ * cannot be programmed for 1 byte writes.
+ * currently there are no known i2c parts that we need to probe
+ * and that cannot be safely read.
+ */
+static int	i2cProbe( bktr_ptr_t bktr, int addr );
+#define BITD		40
+#define EXTRA_START
+
+/*
+ * probe for an I2C device at addr.
+ */
+static int
+i2cProbe( bktr_ptr_t bktr, int addr )
+{
+	int		x, status;
+
+	/* the START */
+#if defined( EXTRA_START )
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD );	/* release data */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD );	/* release clock */
+#endif /* EXTRA_START */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD );	/* lower data */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD );	/* lower clock */
+
+	/* write addr */
+	for ( x = 7; x >= 0; --x ) {
+		if ( addr & (1<<x) ) {
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+			DELAY( BITD );		/* assert HI data */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 3);
+			DELAY( BITD );		/* strobe clock */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 1);
+			DELAY( BITD );		/* release clock */
+		}
+		else {
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
+			DELAY( BITD );		/* assert LO data */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 2);
+			DELAY( BITD );		/* strobe clock */
+			OUTL(bktr, BKTR_I2C_DATA_CTL, 0);
+			DELAY( BITD );		/* release clock */
+		}
+	}
+
+	/* look for an ACK */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD );	/* float data */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD );	/* strobe clock */
+	status = INL(bktr, BKTR_I2C_DATA_CTL) & 1;	/* read the ACK bit */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD );	/* release clock */
+
+	/* the STOP */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD );	/* lower clock & data */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD );	/* release clock */
+	OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD );	/* release data */
+
+	return( status );
+}
+#undef EXTRA_START
+#undef BITD
+
+#endif /* I2C_SOFTWARE_PROBE */
+
+
+#define ABSENT		(-1)
+
+#endif /* FreeBSD, BSDI, NetBSD, OpenBSD */
diff --git a/sys/dev/pci/bktr/bktr_core.h b/sys/dev/pci/bktr/bktr_core.h
new file mode 100644
index 00000000000..2fd3c5bf42c
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_core.h
@@ -0,0 +1,97 @@
+/*	$OpenBSD: bktr_core.h,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_core.h,v 1.4 2000/06/26 09:41:32 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_core : This deals with the Bt848/849/878/879 PCI Frame Grabber,
+ *               Handles all the open, close, ioctl and read userland calls.
+ *               Sets the Bt848 registers and generates RISC pograms.
+ *               Controls the i2c bus and GPIO interface.
+ *               Contains the interface to the kernel.
+ *               (eg probe/attach and open/close/ioctl)
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+int		i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 );
+int		i2cRead( bktr_ptr_t bktr, int addr );
+
+void            msp_dpl_reset( bktr_ptr_t bktr, int i2d_addr );
+unsigned int    msp_dpl_read( bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr );
+void            msp_dpl_write( bktr_ptr_t bktr, int i2c_addr, unsigned char dev,
+			       unsigned int addr, unsigned int data );
+
+
+/*
+ * Defines for userland processes blocked in this driver
+ *   For /dev/bktr[n] use memory address of bktr structure
+ *   For /dev/vbi[n] use memory address of bktr structure + 1
+ *                   this is ok as the bktr structure is > 1 byte
+ */                 
+#define BKTR_SLEEP  ((caddr_t)bktr    )
+#define VBI_SLEEP   ((caddr_t)bktr + 1)
+
+
+/* device name for printf */
+const char *bktr_name(bktr_ptr_t bktr);
+
+/* Prototypes for attatch and interrupt functions */
+void	common_bktr_attach( bktr_ptr_t bktr, int unit,
+			u_long pci_id, u_int rev ); 
+int	common_bktr_intr( void *arg );
+
+
+/* Prototypes for open, close, read, mmap and ioctl calls */
+int	video_open( bktr_ptr_t bktr ); 
+int	video_close( bktr_ptr_t bktr );
+int	video_read( bktr_ptr_t bktr, int unit, dev_t dev, struct uio *uio );
+int	video_ioctl( bktr_ptr_t bktr, int unit,
+			ioctl_cmd_t cmd, caddr_t arg, struct proc* pr );
+
+
+int	tuner_open( bktr_ptr_t bktr );
+int	tuner_close( bktr_ptr_t bktr );
+int	tuner_ioctl( bktr_ptr_t bktr, int unit,
+			ioctl_cmd_t cmd, caddr_t arg, struct proc* pr );
+
+int	vbi_open( bktr_ptr_t bktr );
+int	vbi_close( bktr_ptr_t bktr );
+int	vbi_read( bktr_ptr_t bktr, struct uio *uio, int ioflag );
+
diff --git a/sys/dev/pci/bktr/bktr_os.c b/sys/dev/pci/bktr/bktr_os.c
new file mode 100644
index 00000000000..0a758773159
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_os.c
@@ -0,0 +1,1703 @@
+/*	$OpenBSD: bktr_os.c,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_os.c,v 1.20 2000/10/20 08:16:53 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_os : This has all the Operating System dependant code,
+ *             probe/attach and open/close/ioctl/read/mmap
+ *             memory allocation
+ *             PCI bus interfacing
+ *             
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the 
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products 
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifdef __FreeBSD__
+#include "bktr.h"
+#endif /* __FreeBSD__ */
+
+#ifndef __OpenBSD__
+#include "opt_bktr.h"		/* include any kernel config options */
+#endif
+
+#define FIFO_RISC_DISABLED      0
+#define ALL_INTS_DISABLED       0
+
+
+/*******************/
+/* *** FreeBSD *** */
+/*******************/
+#ifdef __FreeBSD__
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/uio.h>
+#include <sys/kernel.h>
+#include <sys/signalvar.h>
+#include <sys/mman.h>
+#include <sys/poll.h>
+#include <sys/select.h>
+#include <sys/vnode.h>
+
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/pmap.h>
+#include <vm/vm_extern.h>
+
+#if (__FreeBSD_version >=400000) || (NSMBUS > 0)
+#include <sys/bus.h>		/* used by smbus and newbus */
+#endif
+
+#if (__FreeBSD_version >=300000)
+#include <machine/bus_memio.h>	/* used by bus space */
+#include <machine/bus.h>	/* used by bus space and newbus */
+#include <sys/bus.h>
+#endif
+
+#if (__FreeBSD_version >=400000)
+#include <sys/rman.h>		/* used by newbus */
+#include <machine/resource.h>	/* used by newbus */
+#endif
+
+#if (__FreeBSD_version < 500000)
+#include <machine/clock.h>              /* for DELAY */
+#endif
+
+#include <pci/pcivar.h>
+#include <pci/pcireg.h>
+
+#include <sys/sysctl.h>
+int bt848_card = -1; 
+int bt848_tuner = -1;
+int bt848_reverse_mute = -1; 
+int bt848_format = -1;
+int bt848_slow_msp_audio = -1;
+
+SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
+SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
+SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
+SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
+SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
+SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
+
+#if (__FreeBSD__ == 2)
+#define PCIR_REVID     PCI_CLASS_REG
+#endif
+
+#endif /* end freebsd section */
+
+
+
+/****************/
+/* *** BSDI *** */
+/****************/
+#ifdef __bsdi__
+#endif /* __bsdi__ */
+
+
+/**************************/
+/* *** OpenBSD/NetBSD *** */
+/**************************/
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/uio.h>
+#include <sys/kernel.h>
+#include <sys/signalvar.h>
+#include <sys/mman.h>
+#include <sys/poll.h>
+#include <sys/select.h>
+#include <sys/vnode.h>
+
+#include <vm/vm.h>
+
+#include <sys/device.h>
+#include <dev/pci/pcivar.h>
+#include <dev/pci/pcireg.h>
+#include <dev/pci/pcidevs.h>
+
+#define BKTR_DEBUG
+#ifdef BKTR_DEBUG
+int bktr_debug = 0;
+#define DPR(x)	(bktr_debug ? printf x : 0)
+#else
+#define DPR(x)
+#endif
+#endif /* __NetBSD__ || __OpenBSD__ */
+
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <dev/ic/bt8xx.h>	/* NetBSD location for .h files */
+#include <dev/pci/bktr/bktr_reg.h>
+#include <dev/pci/bktr/bktr_tuner.h>
+#include <dev/pci/bktr/bktr_card.h>
+#include <dev/pci/bktr/bktr_audio.h>
+#include <dev/pci/bktr/bktr_core.h>
+#include <dev/pci/bktr/bktr_os.h>
+#else					/* Traditional location for .h files */
+#include <machine/ioctl_meteor.h>
+#include <machine/ioctl_bt848.h>	/* extensions to ioctl_meteor.h */
+#include <dev/bktr/bktr_reg.h>
+#include <dev/bktr/bktr_tuner.h>
+#include <dev/bktr/bktr_card.h>
+#include <dev/bktr/bktr_audio.h>
+#include <dev/bktr/bktr_core.h>
+#include <dev/bktr/bktr_os.h>
+#if defined(BKTR_USE_FREEBSD_SMBUS)
+#include <dev/bktr/bktr_i2c.h>
+#endif
+#endif
+
+
+
+/****************************/
+/* *** FreeBSD 4.x code *** */
+/****************************/
+#if (__FreeBSD_version >= 400000)
+
+static int	bktr_probe( device_t dev );
+static int	bktr_attach( device_t dev );
+static int	bktr_detach( device_t dev );
+static int	bktr_shutdown( device_t dev );
+static void	bktr_intr(void *arg) { common_bktr_intr(arg); }
+
+static device_method_t bktr_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,         bktr_probe),
+	DEVMETHOD(device_attach,        bktr_attach),
+	DEVMETHOD(device_detach,        bktr_detach),
+	DEVMETHOD(device_shutdown,      bktr_shutdown),
+
+	{ 0, 0 }
+};
+
+static driver_t bktr_driver = {
+	"bktr",
+	bktr_methods,
+	sizeof(struct bktr_softc),
+};
+
+static devclass_t bktr_devclass;
+
+static	d_open_t	bktr_open;
+static	d_close_t	bktr_close;
+static	d_read_t	bktr_read;
+static	d_write_t	bktr_write;
+static	d_ioctl_t	bktr_ioctl;
+static	d_mmap_t	bktr_mmap;
+static	d_poll_t	bktr_poll;
+
+#define CDEV_MAJOR 92 
+static struct cdevsw bktr_cdevsw = {
+	/* open */	bktr_open,
+	/* close */	bktr_close,
+	/* read */	bktr_read,
+	/* write */	bktr_write,
+	/* ioctl */	bktr_ioctl,
+	/* poll */	bktr_poll,
+	/* mmap */	bktr_mmap,
+	/* strategy */	nostrategy,
+	/* name */	"bktr",
+	/* maj */	CDEV_MAJOR,
+	/* dump */	nodump,
+	/* psize */	nopsize,
+	/* flags */	0,
+	/* bmaj */	-1
+};
+
+DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
+#if (__FreeBSD_version > 410000)
+MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
+MODULE_VERSION(bktr, 1);
+#endif
+
+
+/*
+ * the boot time probe routine.
+ */
+static int
+bktr_probe( device_t dev )
+{
+	unsigned int type = pci_get_devid(dev);
+        unsigned int rev  = pci_get_revid(dev);
+
+	if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
+	{
+		switch (PCI_PRODUCT(type)) {
+		case PCI_PRODUCT_BROOKTREE_BT848:
+			if (rev == 0x12)
+				device_set_desc(dev, "BrookTree 848A");
+			else
+				device_set_desc(dev, "BrookTree 848");
+			return 0;
+		case PCI_PRODUCT_BROOKTREE_BT849:
+			device_set_desc(dev, "BrookTree 849A");
+			return 0;
+		case PCI_PRODUCT_BROOKTREE_BT878:
+			device_set_desc(dev, "BrookTree 878");
+			return 0;
+		case PCI_PRODUCT_BROOKTREE_BT879:
+			device_set_desc(dev, "BrookTree 879");
+			return 0;
+		}
+	};
+
+        return ENXIO;
+}
+
+
+/*
+ * the attach routine.
+ */
+static int
+bktr_attach( device_t dev )
+{
+	u_long		latency;
+	u_long		fun;
+	u_long		val;
+	unsigned int	rev;
+	unsigned int	unit;
+	int		error = 0;
+#ifdef BROOKTREE_IRQ
+	u_long		old_irq, new_irq;
+#endif 
+
+        struct bktr_softc *bktr = device_get_softc(dev);
+
+	unit = device_get_unit(dev);
+
+	/* build the device name for bktr_name() */
+	snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
+
+	/*
+	 * Enable bus mastering and Memory Mapped device
+	 */
+	val = pci_read_config(dev, PCIR_COMMAND, 4);
+	val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
+	pci_write_config(dev, PCIR_COMMAND, val, 4);
+
+	/*
+	 * Map control/status registers.
+	 */
+	bktr->mem_rid = PCIR_MAPS;
+	bktr->res_mem = bus_alloc_resource(dev, SYS_RES_MEMORY, &bktr->mem_rid,
+					0, ~0, 1, RF_ACTIVE);
+
+
+	if (!bktr->res_mem) {
+		device_printf(dev, "could not map memory\n");
+		error = ENXIO;
+		goto fail;
+	}
+	bktr->memt = rman_get_bustag(bktr->res_mem);
+	bktr->memh = rman_get_bushandle(bktr->res_mem);
+
+
+	/*
+	 * Disable the brooktree device
+	 */
+	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+
+
+#ifdef BROOKTREE_IRQ		/* from the configuration file */
+	old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
+	pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
+	new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
+	printf("bktr%d: attach: irq changed from %d to %d\n",
+		unit, (old_irq & 0xff), (new_irq & 0xff));
+#endif 
+
+	/*
+	 * Allocate our interrupt.
+	 */
+	bktr->irq_rid = 0;
+	bktr->res_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &bktr->irq_rid,
+				0, ~0, 1, RF_SHAREABLE | RF_ACTIVE);
+	if (bktr->res_irq == NULL) {
+		device_printf(dev, "could not map interrupt\n");
+		error = ENXIO;
+		goto fail;
+	}
+
+	error = bus_setup_intr(dev, bktr->res_irq, INTR_TYPE_TTY,
+                               bktr_intr, bktr, &bktr->res_ih);
+	if (error) {
+		device_printf(dev, "could not setup irq\n");
+		goto fail;
+
+	}
+
+
+	/* Update the Device Control Register */
+	/* on Bt878 and Bt879 cards           */
+	fun = pci_read_config( dev, 0x40, 2);
+        fun = fun | 1;	/* Enable writes to the sub-system vendor ID */
+
+#if defined( BKTR_430_FX_MODE )
+	if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
+        fun = fun | 2;	/* Enable Intel 430 FX compatibility mode */
+#endif
+
+#if defined( BKTR_SIS_VIA_MODE )
+	if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
+        fun = fun | 4;	/* Enable SiS/VIA compatibility mode (usefull for
+                           OPTi chipset motherboards too */
+#endif
+	pci_write_config(dev, 0x40, fun, 2);
+
+
+	/* XXX call bt848_i2c dependent attach() routine */
+#if defined(BKTR_USE_FREEBSD_SMBUS)
+	if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc))
+		printf("bktr%d: i2c_attach: can't attach\n", unit);
+#endif
+
+
+/*
+ * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
+ * you have more than four, then 16 would probably be a better value.
+ */
+#ifndef BROOKTREE_DEF_LATENCY_VALUE
+#define BROOKTREE_DEF_LATENCY_VALUE	10
+#endif
+	latency = pci_read_config(dev, PCI_LATENCY_TIMER, 4);
+	latency = (latency >> 8) & 0xff;
+	if ( bootverbose ) {
+		if (latency)
+			printf("brooktree%d: PCI bus latency is", unit);
+		else
+			printf("brooktree%d: PCI bus latency was 0 changing to",
+				unit);
+	}
+	if ( !latency ) {
+		latency = BROOKTREE_DEF_LATENCY_VALUE;
+		pci_write_config(dev, PCI_LATENCY_TIMER, latency<<8, 4);
+	}
+	if ( bootverbose ) {
+		printf(" %d.\n", (int) latency);
+	}
+
+	/* read the pci device id and revision id */
+	fun = pci_get_devid(dev);
+        rev = pci_get_revid(dev);
+
+	/* call the common attach code */
+	common_bktr_attach( bktr, unit, fun, rev );
+
+	/* make the device entries */
+	bktr->bktrdev = make_dev(&bktr_cdevsw, unit,    
+				0, 0, 0444, "bktr%d",  unit);
+	bktr->tunerdev= make_dev(&bktr_cdevsw, unit+16,
+				0, 0, 0444, "tuner%d", unit);
+	bktr->vbidev  = make_dev(&bktr_cdevsw, unit+32,
+				0, 0, 0444, "vbi%d"  , unit);
+
+
+	/* if this is unit 0 (/dev/bktr0, /dev/tuner0, /dev/vbi0) then make */
+	/* alias entries to /dev/bktr /dev/tuner and /dev/vbi */
+#if (__FreeBSD_version >=500000)
+	if (unit == 0) {
+		bktr->bktrdev_alias = make_dev_alias(bktr->bktrdev,  "bktr");
+		bktr->tunerdev_alias= make_dev_alias(bktr->tunerdev, "tuner");
+		bktr->vbidev_alias  = make_dev_alias(bktr->vbidev,   "vbi");
+	}
+#endif
+
+	return 0;
+
+fail:
+	if (bktr->res_irq)
+		bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
+	if (bktr->res_mem)
+		bus_release_resource(dev, SYS_RES_IRQ, bktr->mem_rid, bktr->res_mem);
+	return error;
+
+}
+
+/*
+ * the detach routine.
+ */
+static int
+bktr_detach( device_t dev )
+{
+	unsigned int	unit;
+
+	struct bktr_softc *bktr = device_get_softc(dev);
+
+	unit = device_get_unit(dev);
+
+	/* Disable the brooktree device */
+	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+
+	/* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */
+	/* The memory is retained by the bktr_mem module so we can unload and */
+	/* then reload the main bktr driver module */
+
+	/* Unregister the /dev/bktrN, tunerN and vbiN devices */
+	destroy_dev(bktr->vbidev);
+	destroy_dev(bktr->tunerdev);
+	destroy_dev(bktr->bktrdev);
+
+	/* If this is unit 0, then destroy the alias entries too */
+#if (__FreeBSD_version >=500000)
+	if (unit == 0) {
+	    destroy_dev(bktr->vbidev_alias);
+	    destroy_dev(bktr->tunerdev_alias);
+	    destroy_dev(bktr->bktrdev_alias);
+	}
+#endif
+
+	/*
+	 * Deallocate resources.
+	 */
+	bus_teardown_intr(dev, bktr->res_irq, bktr->res_ih);
+	bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
+	bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem);
+	 
+	return 0;
+}
+
+/*
+ * the shutdown routine.
+ */
+static int
+bktr_shutdown( device_t dev )
+{
+	struct bktr_softc *bktr = device_get_softc(dev);
+
+	/* Disable the brooktree device */
+	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+
+	return 0;
+}
+
+
+/*
+ * Special Memory Allocation
+ */
+vm_offset_t
+get_bktr_mem( int unit, unsigned size )
+{
+	vm_offset_t	addr = 0;
+
+	addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24);
+	if (addr == 0)
+		addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE);
+	if (addr == 0) {
+		printf("bktr%d: Unable to allocate %d bytes of memory.\n",
+			unit, size);
+	}
+
+	return( addr );
+}
+
+
+/*---------------------------------------------------------
+**
+**	BrookTree 848 character device driver routines
+**
+**---------------------------------------------------------
+*/
+
+#define VIDEO_DEV	0x00
+#define TUNER_DEV	0x01
+#define VBI_DEV		0x02
+
+#define UNIT(x)		((x) & 0x0f)
+#define FUNCTION(x)	(x >> 4)
+
+/*
+ * 
+ */
+int
+bktr_open( dev_t dev, int flags, int fmt, struct proc *p )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+	int		result;
+
+	unit = UNIT( minor(dev) );
+
+	/* Get the device data */
+	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
+	if (bktr == NULL) {
+		/* the device is no longer valid/functioning */
+		return (ENXIO);
+	}
+
+	if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
+		return( ENXIO );	
+
+	/* Record that the device is now busy */
+	device_busy(devclass_get_device(bktr_devclass, unit)); 
+
+
+	if (bt848_card != -1) {
+	  if ((bt848_card >> 8   == unit ) &&
+	     ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
+	    if ( bktr->bt848_card != (bt848_card & 0xff) ) {
+	      bktr->bt848_card = (bt848_card & 0xff);
+	      probeCard(bktr, FALSE, unit);
+	    }
+	  }
+	}
+
+	if (bt848_tuner != -1) {
+	  if ((bt848_tuner >> 8   == unit ) &&
+	     ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
+	    if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
+	      bktr->bt848_tuner = (bt848_tuner & 0xff);
+	      probeCard(bktr, FALSE, unit);
+	    }
+	  }
+	}
+
+	if (bt848_reverse_mute != -1) {
+	  if ((bt848_reverse_mute >> 8)   == unit ) {
+	    bktr->reverse_mute = bt848_reverse_mute & 0xff;
+	  }
+	}
+
+	if (bt848_slow_msp_audio != -1) {
+	  if ((bt848_slow_msp_audio >> 8) == unit ) {
+	      bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
+	  }
+	}
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		result = video_open( bktr );
+		break;
+	case TUNER_DEV:
+		result = tuner_open( bktr );
+		break;
+	case VBI_DEV:
+		result = vbi_open( bktr );
+		break;
+	default:
+		result = ENXIO;
+		break;
+	}
+
+	/* If there was an error opening the device, undo the busy status */
+	if (result != 0)
+		device_unbusy(devclass_get_device(bktr_devclass, unit)); 
+	return( result );
+}
+
+
+/*
+ * 
+ */
+int
+bktr_close( dev_t dev, int flags, int fmt, struct proc *p )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+	int		result;
+
+	unit = UNIT( minor(dev) );
+
+	/* Get the device data */
+	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
+	if (bktr == NULL) {
+		/* the device is no longer valid/functioning */
+		return (ENXIO);
+	}
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		result = video_close( bktr );
+		break;
+	case TUNER_DEV:
+		result = tuner_close( bktr );
+		break;
+	case VBI_DEV:
+		result = vbi_close( bktr );
+		break;
+	default:
+		return (ENXIO);
+		break;
+	}
+
+	device_unbusy(devclass_get_device(bktr_devclass, unit)); 
+	return( result );
+}
+
+
+/*
+ * 
+ */
+int
+bktr_read( dev_t dev, struct uio *uio, int ioflag )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+	
+	unit = UNIT(minor(dev));
+
+	/* Get the device data */
+	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
+	if (bktr == NULL) {
+		/* the device is no longer valid/functioning */
+		return (ENXIO);
+	}
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		return( video_read( bktr, unit, dev, uio ) );
+	case VBI_DEV:
+		return( vbi_read( bktr, uio, ioflag ) );
+	}
+        return( ENXIO );
+}
+
+
+/*
+ * 
+ */
+int
+bktr_write( dev_t dev, struct uio *uio, int ioflag )
+{
+	return( EINVAL ); /* XXX or ENXIO ? */
+}
+
+
+/*
+ * 
+ */
+int
+bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT(minor(dev));
+
+	/* Get the device data */
+	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
+	if (bktr == NULL) {
+		/* the device is no longer valid/functioning */
+		return (ENXIO);
+	}
+
+	if (bktr->bigbuf == 0)	/* no frame buffer allocated (ioctl failed) */
+		return( ENOMEM );
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		return( video_ioctl( bktr, unit, cmd, arg, pr ) );
+	case TUNER_DEV:
+		return( tuner_ioctl( bktr, unit, cmd, arg, pr ) );
+	}
+
+	return( ENXIO );
+}
+
+
+/*
+ * 
+ */
+int
+bktr_mmap( dev_t dev, vm_offset_t offset, int nprot )
+{
+	int		unit;
+	bktr_ptr_t	bktr;
+
+	unit = UNIT(minor(dev));
+
+	if (FUNCTION(minor(dev)) > 0)	/* only allow mmap on /dev/bktr[n] */
+		return( -1 );
+
+	/* Get the device data */
+	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
+	if (bktr == NULL) {
+		/* the device is no longer valid/functioning */
+		return (ENXIO);
+	}
+
+	if (nprot & PROT_EXEC)
+		return( -1 );
+
+	if (offset < 0)
+		return( -1 );
+
+	if (offset >= bktr->alloc_pages * PAGE_SIZE)
+		return( -1 );
+
+	return( atop(vtophys(bktr->bigbuf) + offset) );
+}
+
+int bktr_poll( dev_t dev, int events, struct proc *p)
+{
+	int		unit;
+	bktr_ptr_t	bktr;
+	int revents = 0; 
+	DECLARE_INTR_MASK(s);
+
+	unit = UNIT(minor(dev));
+
+	/* Get the device data */
+	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
+	if (bktr == NULL) {
+		/* the device is no longer valid/functioning */
+		return (ENXIO);
+	}
+
+	DISABLE_INTR(s);
+
+	if (events & (POLLIN | POLLRDNORM)) {
+
+		switch ( FUNCTION( minor(dev) ) ) {
+		case VBI_DEV:
+			if(bktr->vbisize == 0)
+				selrecord(p, &bktr->vbi_select);
+			else
+				revents |= events & (POLLIN | POLLRDNORM);
+			break;
+		}
+	}
+
+	ENABLE_INTR(s);
+
+	return (revents);
+}
+
+#endif		/* FreeBSD 4.x specific kernel interface routines */
+
+/**********************************/
+/* *** FreeBSD 2.2.x and 3.x  *** */
+/**********************************/
+
+#if ((__FreeBSD__ == 2) || (__FreeBSD__ == 3))
+
+static bktr_reg_t brooktree[ NBKTR ];
+
+static const char*	bktr_probe( pcici_t tag, pcidi_t type );
+static void		bktr_attach( pcici_t tag, int unit );
+static void		bktr_intr(void *arg) { common_bktr_intr(arg); }
+
+static u_long	bktr_count;
+
+static struct	pci_device bktr_device = {
+	"bktr",
+	bktr_probe,
+	bktr_attach,
+	&bktr_count
+};
+
+DATA_SET (pcidevice_set, bktr_device);
+
+static	d_open_t	bktr_open;
+static	d_close_t	bktr_close;
+static	d_read_t	bktr_read;
+static	d_write_t	bktr_write;
+static	d_ioctl_t	bktr_ioctl;
+static	d_mmap_t	bktr_mmap;
+static	d_poll_t	bktr_poll;
+
+#define CDEV_MAJOR 92 
+static struct cdevsw bktr_cdevsw = 
+{
+	bktr_open,	bktr_close,	bktr_read,	bktr_write,
+	bktr_ioctl,	nostop,		nullreset,	nodevtotty,
+	bktr_poll,	bktr_mmap,	NULL,		"bktr",
+	NULL,		-1
+};
+
+static int bktr_devsw_installed;
+
+static void
+bktr_drvinit( void *unused )
+{
+	dev_t dev;
+
+	if ( ! bktr_devsw_installed ) {
+		dev = makedev(CDEV_MAJOR, 0);
+		cdevsw_add(&dev,&bktr_cdevsw, NULL);
+		bktr_devsw_installed = 1;
+	}
+}
+
+SYSINIT(bktrdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bktr_drvinit,NULL)
+
+/*
+ * the boot time probe routine.
+ */
+static const char*
+bktr_probe( pcici_t tag, pcidi_t type )
+{
+        unsigned int rev = pci_conf_read( tag, PCIR_REVID) & 0x000000ff;
+
+	if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
+	{
+		switch (PCI_PRODUCT(type)) {
+		case PCI_PRODUCT_BROOKTREE_BT848:
+			if (rev == 0x12) return("BrookTree 848A");
+			else             return("BrookTree 848");
+		case PCI_PRODUCT_BROOKTREE_BT849:
+			return("BrookTree 849A");
+		case PCI_PRODUCT_BROOKTREE_BT878:
+			return("BrookTree 878");
+		case PCI_PRODUCT_BROOKTREE_BT879:
+			return("BrookTree 879");
+		}
+	};
+
+	return ((char *)0);
+}
+
+/*
+ * the attach routine.
+ */
+static	void
+bktr_attach( pcici_t tag, int unit )
+{
+	bktr_ptr_t	bktr;
+	u_long		latency;
+	u_long		fun;
+	unsigned int	rev;
+	unsigned long	base;
+#ifdef BROOKTREE_IRQ
+	u_long		old_irq, new_irq;
+#endif 
+
+	bktr = &brooktree[unit];
+
+	if (unit >= NBKTR) {
+		printf("brooktree%d: attach: only %d units configured.\n",
+		        unit, NBKTR);
+		printf("brooktree%d: attach: invalid unit number.\n", unit);
+		return;
+	}
+
+	/* build the device name for bktr_name() */
+	snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
+
+	/* Enable Memory Mapping */
+	fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG);
+	pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 2);
+
+	/* Enable Bus Mastering */
+	fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG);
+	pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 4);
+
+	bktr->tag = tag;
+
+
+	/*
+	 * Map control/status registers
+	 */
+	pci_map_mem( tag, PCI_MAP_REG_START, (vm_offset_t *) &base,
+		     &bktr->phys_base );
+#if (__FreeBSD_version >= 300000)
+	bktr->memt = I386_BUS_SPACE_MEM; /* XXX should use proper bus space */
+	bktr->memh = (bus_space_handle_t)base; /* XXX functions here */
+#endif
+
+	/*
+	 * Disable the brooktree device
+	 */
+	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+
+#ifdef BROOKTREE_IRQ		/* from the configuration file */
+	old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
+	pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
+	new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
+	printf("bktr%d: attach: irq changed from %d to %d\n",
+		unit, (old_irq & 0xff), (new_irq & 0xff));
+#endif 
+
+	/*
+	 * setup the interrupt handling routine
+	 */
+	pci_map_int(tag, bktr_intr, (void*) bktr, &tty_imask);
+
+
+	/* Update the Device Control Register */
+	/* on Bt878 and Bt879 cards */
+	fun = pci_conf_read(tag, 0x40);
+        fun = fun | 1;	/* Enable writes to the sub-system vendor ID */
+
+#if defined( BKTR_430_FX_MODE )
+	if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
+        fun = fun | 2;	/* Enable Intel 430 FX compatibility mode */
+#endif
+
+#if defined( BKTR_SIS_VIA_MODE )
+	if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
+        fun = fun | 4;	/* Enable SiS/VIA compatibility mode (usefull for
+                           OPTi chipset motherboards too */
+#endif
+	pci_conf_write(tag, 0x40, fun);
+
+
+	/* XXX call bt848_i2c dependent attach() routine */
+#if defined(BKTR_USE_FREEBSD_SMBUS)
+	if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc))
+		printf("bktr%d: i2c_attach: can't attach\n", unit);
+#endif
+
+
+/*
+ * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
+ * you have more than four, then 16 would probably be a better value.
+ */
+#ifndef BROOKTREE_DEF_LATENCY_VALUE
+#define BROOKTREE_DEF_LATENCY_VALUE	10
+#endif
+	latency = pci_conf_read(tag, PCI_LATENCY_TIMER);
+	latency = (latency >> 8) & 0xff;
+	if ( bootverbose ) {
+		if (latency)
+			printf("brooktree%d: PCI bus latency is", unit);
+		else
+			printf("brooktree%d: PCI bus latency was 0 changing to",
+				unit);
+	}
+	if ( !latency ) {
+		latency = BROOKTREE_DEF_LATENCY_VALUE;
+		pci_conf_write(tag, PCI_LATENCY_TIMER,	latency<<8);
+	}
+	if ( bootverbose ) {
+		printf(" %d.\n", (int) latency);
+	}
+
+
+	/* read the pci device id and revision id */
+	fun = pci_conf_read(tag, PCI_ID_REG);
+        rev = pci_conf_read(tag, PCIR_REVID) & 0x000000ff;
+
+	/* call the common attach code */
+	common_bktr_attach( bktr, unit, fun, rev );
+
+}
+
+
+/*
+ * Special Memory Allocation
+ */
+vm_offset_t
+get_bktr_mem( int unit, unsigned size )
+{
+	vm_offset_t	addr = 0;
+
+	addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff, 1<<24);
+	if (addr == 0)
+		addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff,
+								PAGE_SIZE);
+	if (addr == 0) {
+		printf("bktr%d: Unable to allocate %d bytes of memory.\n",
+			unit, size);
+	}
+
+	return( addr );
+}
+
+/*---------------------------------------------------------
+**
+**	BrookTree 848 character device driver routines
+**
+**---------------------------------------------------------
+*/
+
+
+#define VIDEO_DEV	0x00
+#define TUNER_DEV	0x01
+#define VBI_DEV		0x02
+
+#define UNIT(x)		((x) & 0x0f)
+#define FUNCTION(x)	((x >> 4) & 0x0f)
+
+
+/*
+ * 
+ */
+int
+bktr_open( dev_t dev, int flags, int fmt, struct proc *p )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT( minor(dev) );
+	if (unit >= NBKTR)			/* unit out of range */
+		return( ENXIO );
+
+	bktr = &(brooktree[ unit ]);
+
+	if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
+		return( ENXIO );	
+
+
+	if (bt848_card != -1) {
+	  if ((bt848_card >> 8   == unit ) &&
+	     ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
+	    if ( bktr->bt848_card != (bt848_card & 0xff) ) {
+	      bktr->bt848_card = (bt848_card & 0xff);
+	      probeCard(bktr, FALSE, unit);
+	    }
+	  }
+	}
+
+	if (bt848_tuner != -1) {
+	  if ((bt848_tuner >> 8   == unit ) &&
+	     ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
+	    if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
+	      bktr->bt848_tuner = (bt848_tuner & 0xff);
+	      probeCard(bktr, FALSE, unit);
+	    }
+	  }
+	}
+
+	if (bt848_reverse_mute != -1) {
+	  if ((bt848_reverse_mute >> 8)   == unit ) {
+	    bktr->reverse_mute = bt848_reverse_mute & 0xff;
+	  }
+	}
+
+	if (bt848_slow_msp_audio != -1) {
+	  if ((bt848_slow_msp_audio >> 8) == unit ) {
+	      bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
+	  }
+	}
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		return( video_open( bktr ) );
+	case TUNER_DEV:
+		return( tuner_open( bktr ) );
+	case VBI_DEV:
+		return( vbi_open( bktr ) );
+	}
+	return( ENXIO );
+}
+
+
+/*
+ * 
+ */
+int
+bktr_close( dev_t dev, int flags, int fmt, struct proc *p )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT( minor(dev) );
+	if (unit >= NBKTR)			/* unit out of range */
+		return( ENXIO );
+
+	bktr = &(brooktree[ unit ]);
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		return( video_close( bktr ) );
+	case TUNER_DEV:
+		return( tuner_close( bktr ) );
+	case VBI_DEV:
+		return( vbi_close( bktr ) );
+	}
+
+	return( ENXIO );
+}
+
+/*
+ * 
+ */
+int
+bktr_read( dev_t dev, struct uio *uio, int ioflag )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+	
+	unit = UNIT(minor(dev));
+	if (unit >= NBKTR)	/* unit out of range */
+		return( ENXIO );
+
+	bktr = &(brooktree[unit]);
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		return( video_read( bktr, unit, dev, uio ) );
+	case VBI_DEV:
+		return( vbi_read( bktr, uio, ioflag ) );
+	}
+        return( ENXIO );
+}
+
+
+/*
+ * 
+ */
+int
+bktr_write( dev_t dev, struct uio *uio, int ioflag )
+{
+	return( EINVAL ); /* XXX or ENXIO ? */
+}
+
+/*
+ * 
+ */
+int
+bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr )
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT(minor(dev));
+	if (unit >= NBKTR)	/* unit out of range */
+		return( ENXIO );
+
+	bktr = &(brooktree[ unit ]);
+
+	if (bktr->bigbuf == 0)	/* no frame buffer allocated (ioctl failed) */
+		return( ENOMEM );
+
+	switch ( FUNCTION( minor(dev) ) ) {
+	case VIDEO_DEV:
+		return( video_ioctl( bktr, unit, cmd, arg, pr ) );
+	case TUNER_DEV:
+		return( tuner_ioctl( bktr, unit, cmd, arg, pr ) );
+	}
+
+	return( ENXIO );
+}
+
+/*
+ * bktr_mmap.
+ * Note: 2.2.5/2.2.6/2.2.7/3.0 users must manually
+ * edit the line below and change  "vm_offset_t" to "int"
+ */
+int bktr_mmap( dev_t dev, vm_offset_t offset, int nprot )
+
+{
+	int		unit;
+	bktr_ptr_t	bktr;
+
+	unit = UNIT(minor(dev));
+
+	if (unit >= NBKTR || FUNCTION(minor(dev)) > 0)
+		return( -1 );
+
+	bktr = &(brooktree[ unit ]);
+
+	if (nprot & PROT_EXEC)
+		return( -1 );
+
+	if (offset < 0)
+		return( -1 );
+
+	if (offset >= bktr->alloc_pages * PAGE_SIZE)
+		return( -1 );
+
+	return( i386_btop(vtophys(bktr->bigbuf) + offset) );
+}
+
+int bktr_poll( dev_t dev, int events, struct proc *p)
+{
+	int		unit;
+	bktr_ptr_t	bktr;
+	int revents = 0; 
+
+	unit = UNIT(minor(dev));
+
+	if (unit >= NBKTR)
+		return( -1 );
+
+	bktr = &(brooktree[ unit ]);
+
+	disable_intr();
+
+	if (events & (POLLIN | POLLRDNORM)) {
+
+		switch ( FUNCTION( minor(dev) ) ) {
+		case VBI_DEV:
+			if(bktr->vbisize == 0)
+				selrecord(p, &bktr->vbi_select);
+			else
+				revents |= events & (POLLIN | POLLRDNORM);
+			break;
+		}
+	}
+
+	enable_intr();
+
+	return (revents);
+}
+
+
+#endif		/* FreeBSD 2.2.x and 3.x specific kernel interface routines */
+
+
+/*****************/
+/* *** BSDI  *** */
+/*****************/
+
+#if defined(__bsdi__)
+#endif		/* __bsdi__ BSDI specific kernel interface routines */
+
+
+/*****************************/
+/* *** OpenBSD / NetBSD  *** */
+/*****************************/
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+
+#define IPL_VIDEO       IPL_BIO         /* XXX */
+
+static	int		bktr_intr(void *arg) { return common_bktr_intr(arg); }
+
+#define bktr_open       bktropen
+#define bktr_close      bktrclose
+#define bktr_read       bktrread
+#define bktr_write      bktrwrite
+#define bktr_ioctl      bktrioctl
+#define bktr_mmap       bktrmmap
+
+#ifdef __OpenBSD__
+int	bktr_open __P((dev_t, int, int, struct proc *));
+int	bktr_close __P((dev_t, int, int, struct proc *));
+int	bktr_read __P((dev_t, struct uio *, int));
+int	bktr_write __P((dev_t, struct uio *, int));
+int	bktr_ioctl __P((dev_t, ioctl_cmd_t, caddr_t, int, struct proc *));
+paddr_t	bktr_mmap __P((dev_t, off_t, int));
+#endif
+
+vm_offset_t vm_page_alloc_contig(vm_offset_t, vm_offset_t,
+                                 vm_offset_t, vm_offset_t);
+
+#if defined(__OpenBSD__)
+static int      bktr_probe __P((struct device *, void *, void *));
+#else
+static int      bktr_probe __P((struct device *, struct cfdata *, void *));
+#endif
+static void     bktr_attach __P((struct device *, struct device *, void *));
+
+struct cfattach bktr_ca = {
+        sizeof(struct bktr_softc), bktr_probe, bktr_attach
+};
+
+#if defined(__NetBSD__)
+extern struct cfdriver bktr_cd;
+#else
+struct cfdriver bktr_cd = {
+        NULL, "bktr", DV_DULL
+};
+#endif
+
+int
+bktr_probe(parent, match, aux)
+	struct device *parent;
+#if defined(__OpenBSD__)
+        void *match;
+#else
+        struct cfdata *match;
+#endif
+        void *aux;
+{
+        struct pci_attach_args *pa = aux;
+
+        if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_BROOKTREE &&
+            (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT848 ||
+             PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT849 ||
+             PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT878 ||
+             PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT879))
+                return 1;
+
+        return 0;
+}
+
+
+/*
+ * the attach routine.
+ */
+static void
+bktr_attach(struct device *parent, struct device *self, void *aux)
+{
+	bktr_ptr_t	bktr;
+	u_long		latency;
+	u_long		fun;
+	unsigned int	rev;
+	struct pci_attach_args *pa = aux;
+	pci_intr_handle_t ih;
+	const char *intrstr;
+	int retval;
+	int unit;
+
+	bktr = (bktr_ptr_t)self;
+	unit = bktr->bktr_dev.dv_unit;
+        bktr->dmat = pa->pa_dmat;
+
+#ifndef __OpenBSD__
+	printf("\n");
+#endif
+
+	/*
+	 * map memory
+	 */
+	retval = pci_mapreg_map(pa, PCI_MAPREG_START,
+				PCI_MAPREG_TYPE_MEM
+				| PCI_MAPREG_MEM_TYPE_32BIT, 0,
+				&bktr->memt, &bktr->memh, NULL,
+				&bktr->obmemsz);
+	DPR(("pci_mapreg_map: memt %x, memh %x, size %x\n",
+	     bktr->memt, (u_int)bktr->memh, (u_int)bktr->obmemsz));
+	if (retval) {
+		printf("%s: couldn't map memory\n", bktr_name(bktr));
+		return;
+	}
+
+	/*
+	 * Disable the brooktree device
+	 */
+	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
+	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
+	
+	/*
+	 * map interrupt
+	 */
+	if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
+			 pa->pa_intrline, &ih)) {
+		printf("%s: couldn't map interrupt\n",
+		       bktr_name(bktr));
+		return;
+	}
+	intrstr = pci_intr_string(pa->pa_pc, ih);
+	bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
+				      bktr_intr, bktr
+#ifdef __OpenBSD__
+				      , bktr->bktr_dev.dv_xname
+#endif
+	);
+	if (bktr->ih == NULL) {
+		printf("%s: couldn't establish interrupt",
+		       bktr_name(bktr));
+		if (intrstr != NULL)
+			printf(" at %s", intrstr);
+		printf("\n");
+		return;
+	}
+	if (intrstr != NULL)
+#ifdef __NetBSD__
+		printf("%s: interrupting at %s\n", bktr_name(bktr),
+		       intrstr);
+#else
+		printf(": %s\n", intrstr);
+#endif
+	
+/*
+ * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
+ * you have more than four, then 16 would probably be a better value.
+ */
+#ifndef BROOKTREE_DEF_LATENCY_VALUE
+#define BROOKTREE_DEF_LATENCY_VALUE	10
+#endif
+	latency = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_LATENCY_TIMER);
+	latency = (latency >> 8) & 0xff;
+
+	if (!latency) {
+		if (bootverbose) {
+			printf("%s: PCI bus latency was 0 changing to %d",
+			       bktr_name(bktr), BROOKTREE_DEF_LATENCY_VALUE);
+		}
+		latency = BROOKTREE_DEF_LATENCY_VALUE;
+		pci_conf_write(pa->pa_pc, pa->pa_tag, 
+			       PCI_LATENCY_TIMER, latency<<8);
+	}
+
+
+	/* Enabled Bus Master
+	   XXX: check if all old DMA is stopped first (e.g. after warm
+	   boot) */
+	fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
+	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
+		       fun | PCI_COMMAND_MASTER_ENABLE);
+
+	/* read the pci id and determine the card type */
+	fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG);
+        rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0x000000ff;
+
+	common_bktr_attach(bktr, unit, fun, rev);
+}
+
+
+/*
+ * Special Memory Allocation
+ */
+vm_offset_t
+get_bktr_mem(bktr, dmapp, size)
+        bktr_ptr_t bktr;
+        bus_dmamap_t *dmapp;
+        unsigned int size;
+{
+        bus_dma_tag_t dmat = bktr->dmat;
+        bus_dma_segment_t seg;
+        bus_size_t align;
+        int rseg;
+        caddr_t kva;
+
+        /*
+         * Allocate a DMA area
+         */
+        align = 1 << 24;
+        if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
+                             &rseg, BUS_DMA_NOWAIT)) {
+                align = PAGE_SIZE;
+                if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
+                                     &rseg, BUS_DMA_NOWAIT)) {
+                        printf("%s: Unable to dmamem_alloc of %d bytes\n",
+			       bktr_name(bktr), size);
+                        return 0;
+                }
+        }
+        if (bus_dmamem_map(dmat, &seg, rseg, size,
+                           &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
+                printf("%s: Unable to dmamem_map of %d bytes\n",
+                        bktr_name(bktr), size);
+                bus_dmamem_free(dmat, &seg, rseg);
+                return 0;
+        }
+#ifdef __OpenBSD__
+        bktr->dm_mapsize = size;
+#endif
+        /*
+         * Create and locd the DMA map for the DMA area
+         */
+        if (bus_dmamap_create(dmat, size, 1, size, 0, BUS_DMA_NOWAIT, dmapp)) {
+                printf("%s: Unable to dmamap_create of %d bytes\n",
+                        bktr_name(bktr), size);
+                bus_dmamem_unmap(dmat, kva, size);
+                bus_dmamem_free(dmat, &seg, rseg);
+                return 0;
+        }
+        if (bus_dmamap_load(dmat, *dmapp, kva, size, NULL, BUS_DMA_NOWAIT)) {
+                printf("%s: Unable to dmamap_load of %d bytes\n",
+                        bktr_name(bktr), size);
+                bus_dmamem_unmap(dmat, kva, size);
+                bus_dmamem_free(dmat, &seg, rseg);
+                bus_dmamap_destroy(dmat, *dmapp);
+                return 0;
+        }
+        return (vm_offset_t)kva;
+}
+
+void
+free_bktr_mem(bktr, dmap, kva)
+        bktr_ptr_t bktr;
+        bus_dmamap_t dmap;
+        vm_offset_t kva;
+{
+        bus_dma_tag_t dmat = bktr->dmat;
+
+#ifdef __NetBSD__ 
+        bus_dmamem_unmap(dmat, (caddr_t)kva, dmap->dm_mapsize);
+#else
+        bus_dmamem_unmap(dmat, (caddr_t)kva, bktr->dm_mapsize);
+#endif
+        bus_dmamem_free(dmat, dmap->dm_segs, 1);
+        bus_dmamap_destroy(dmat, dmap);
+}
+
+
+/*---------------------------------------------------------
+**
+**	BrookTree 848 character device driver routines
+**
+**---------------------------------------------------------
+*/
+
+
+#define VIDEO_DEV	0x00
+#define TUNER_DEV	0x01
+#define VBI_DEV		0x02
+
+#define UNIT(x)         (minor((x) & 0x0f))
+#define FUNCTION(x)     (minor((x >> 4) & 0x0f))
+
+/*
+ * 
+ */
+int
+bktr_open(dev_t dev, int flags, int fmt, struct proc *p)
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT(dev);
+
+	/* unit out of range */
+	if ((unit > bktr_cd.cd_ndevs) || (bktr_cd.cd_devs[unit] == NULL))
+		return(ENXIO);
+
+	bktr = bktr_cd.cd_devs[unit];
+
+	if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
+		return(ENXIO);	
+
+	switch (FUNCTION(dev)) {
+	case VIDEO_DEV:
+		return(video_open(bktr));
+	case TUNER_DEV:
+		return(tuner_open(bktr));
+	case VBI_DEV:
+		return(vbi_open(bktr));
+	}
+
+	return(ENXIO);
+}
+
+
+/*
+ * 
+ */
+int
+bktr_close(dev_t dev, int flags, int fmt, struct proc *p)
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT(dev);
+
+	bktr = bktr_cd.cd_devs[unit];
+
+	switch (FUNCTION(dev)) {
+	case VIDEO_DEV:
+		return(video_close(bktr));
+	case TUNER_DEV:
+		return(tuner_close(bktr));
+	case VBI_DEV:
+		return(vbi_close(bktr));
+	}
+
+	return(ENXIO);
+}
+
+/*
+ * 
+ */
+int
+bktr_read(dev_t dev, struct uio *uio, int ioflag)
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+	
+	unit = UNIT(dev);
+
+	bktr = bktr_cd.cd_devs[unit];
+
+	switch (FUNCTION(dev)) {
+	case VIDEO_DEV:
+		return(video_read(bktr, unit, dev, uio));
+	case VBI_DEV:
+		return(vbi_read(bktr, uio, ioflag));
+	}
+
+        return(ENXIO);
+}
+
+
+/*
+ * 
+ */
+int
+bktr_write(dev_t dev, struct uio *uio, int ioflag)
+{
+	/* operation not supported */
+	return(EOPNOTSUPP);
+}
+
+/*
+ * 
+ */
+int
+bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr)
+{
+	bktr_ptr_t	bktr;
+	int		unit;
+
+	unit = UNIT(dev);
+
+	bktr = bktr_cd.cd_devs[unit];
+
+	if (bktr->bigbuf == 0)	/* no frame buffer allocated (ioctl failed) */
+		return(ENOMEM);
+
+	switch (FUNCTION(dev)) {
+	case VIDEO_DEV:
+		return(video_ioctl(bktr, unit, cmd, arg, pr));
+	case TUNER_DEV:
+		return(tuner_ioctl(bktr, unit, cmd, arg, pr));
+	}
+
+	return(ENXIO);
+}
+
+/*
+ * 
+ */
+paddr_t
+bktr_mmap(dev_t dev, off_t offset, int nprot)
+{
+	int		unit;
+	bktr_ptr_t	bktr;
+
+	unit = UNIT(dev);
+
+	if (FUNCTION(dev) > 0)	/* only allow mmap on /dev/bktr[n] */
+		return(-1);
+
+	bktr = bktr_cd.cd_devs[unit];
+
+	if ((vaddr_t)offset < 0)
+		return(-1);
+
+	if ((vaddr_t)offset >= bktr->alloc_pages * PAGE_SIZE)
+		return(-1);
+
+	return (bus_dmamem_mmap(bktr->dmat, bktr->dm_mem->dm_segs, 1,
+				(vaddr_t)offset, nprot, BUS_DMA_WAITOK));
+}
+
+#endif /* __NetBSD__ || __OpenBSD__ */
diff --git a/sys/dev/pci/bktr/bktr_os.h b/sys/dev/pci/bktr/bktr_os.h
new file mode 100644
index 00000000000..a20a4a35cfb
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_os.h
@@ -0,0 +1,73 @@
+/*	$OpenBSD: bktr_os.h,v 1.1 2001/03/28 03:27:09 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_os.h,v 1.4 2000/04/16 07:56:58 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_os : This has all the Operating System dependant code.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the 
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products 
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+/******************************/
+/* *** Memory Allocation  *** */
+/******************************/
+#if (defined(__FreeBSD__) || defined(__bsdi__))
+vm_offset_t     get_bktr_mem( int unit, unsigned size );
+#endif
+
+#if (defined(__NetBSD__) || defined(__OpenBSD__))
+vm_offset_t     get_bktr_mem(bktr_ptr_t, bus_dmamap_t *, unsigned size);
+void            free_bktr_mem(bktr_ptr_t, bus_dmamap_t, vm_offset_t);
+#endif 
+
+/************************************/
+/* *** Interrupt Enable/Disable *** */
+/************************************/
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#define DECLARE_INTR_MASK(s)	intrmask_t s
+#define DISABLE_INTR(s)		s=spltty()
+#define ENABLE_INTR(s)		splx(s)
+#else
+#define DECLARE_INTR_MASK(s)	/* no need to declare 's' */
+#define DISABLE_INTR(s)		disable_intr()
+#define ENABLE_INTR(s)		enable_intr()
+#endif
+
+
diff --git a/sys/dev/pci/bktr/bktr_reg.h b/sys/dev/pci/bktr/bktr_reg.h
new file mode 100644
index 00000000000..f6e43ca60c5
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_reg.h
@@ -0,0 +1,729 @@
+/*	$OpenBSD: bktr_reg.h,v 1.1 2001/03/28 03:27:10 fgsch Exp $	*/
+/*
+ * $FreeBSD: src/sys/dev/bktr/bktr_reg.h,v 1.42 2000/10/31 13:09:56 roger Exp $
+ *
+ * Copyright (c) 1999 Roger Hardiman
+ * Copyright (c) 1998 Amancio Hasty
+ * Copyright (c) 1995 Mark Tinguely and Jim Lowe
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Mark Tinguely and Jim Lowe
+ * 4. The name of the author may not be used to endorse or promote products 
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifdef __FreeBSD__
+#  if (__FreeBSD_version >= 310000)
+#    include "smbus.h"
+#  else
+#    define NSMBUS 0		/* FreeBSD before 3.1 does not have SMBUS */
+#  endif
+#  if (NSMBUS > 0)
+#    define BKTR_USE_FREEBSD_SMBUS
+#  endif
+#endif
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <machine/bus.h>		/* struct device */
+#include <sys/device.h>
+#include <sys/select.h>			/* struct selinfo */
+# ifdef DEBUG
+#  define	bootverbose 1
+# else
+#  define	bootverbose 0
+# endif
+#endif
+
+/*
+ * The kernel options for the driver now all begin with BKTR.
+ * Support the older kernel options on FreeBSD and OpenBSD.
+ *
+ */
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#if defined(BROOKTREE_ALLOC_PAGES)
+#define BKTR_ALLOC_PAGES BROOKTREE_ALLOC_PAGES
+#endif
+
+#if defined(BROOKTREE_SYSTEM_DEFAULT)
+#define BKTR_SYSTEM_DEFAULT BROOKTREE_SYSTEM_DEFAULT
+#endif
+
+#if defined(OVERRIDE_CARD)
+#define BKTR_OVERRIDE_CARD OVERRIDE_CARD
+#endif
+
+#if defined(OVERRIDE_TUNER)
+#define BKTR_OVERRIDE_TUNER OVERRIDE_TUNER
+#endif
+
+#if defined(OVERRIDE_DBX)
+#define BKTR_OVERRIDE_DBX OVERRIDE_DBX
+#endif
+
+#if defined(OVERRIDE_MSP)
+#define BKTR_OVERRIDE_MSP OVERRIDE_MSP
+#endif
+
+#endif
+
+
+#ifndef PCI_LATENCY_TIMER
+#define	PCI_LATENCY_TIMER		0x0c	/* pci timer register */
+#endif
+
+/*
+ * Definitions for the Brooktree 848/878 video capture to pci interface.
+ */
+#ifndef __NetBSD__
+#ifdef __OpenBSD__
+#include <dev/pci/pcivar.h>
+#else
+#define PCI_VENDOR_SHIFT                        0
+#define PCI_VENDOR_MASK                         0xffff
+#define PCI_VENDOR(id) \
+            (((id) >> PCI_VENDOR_SHIFT) & PCI_VENDOR_MASK)
+
+#define PCI_PRODUCT_SHIFT                       16
+#define PCI_PRODUCT_MASK                        0xffff
+#define PCI_PRODUCT(id) \
+            (((id) >> PCI_PRODUCT_SHIFT) & PCI_PRODUCT_MASK)
+#endif
+
+/* PCI vendor ID */
+#define PCI_VENDOR_BROOKTREE    0x109e                /* Brooktree */
+/* Brooktree products */
+#define PCI_PRODUCT_BROOKTREE_BT848     0x0350        /* Bt848 Video Capture */
+#define PCI_PRODUCT_BROOKTREE_BT849     0x0351        /* Bt849 Video Capture */
+#define PCI_PRODUCT_BROOKTREE_BT878     0x036e        /* Bt878 Video Capture */
+#define PCI_PRODUCT_BROOKTREE_BT879     0x036f        /* Bt879 Video Capture */
+#endif
+
+#define BROOKTREE_848                   1
+#define BROOKTREE_848A                  2
+#define BROOKTREE_849A                  3
+#define BROOKTREE_878                   4
+#define BROOKTREE_879                   5
+
+typedef volatile u_int 	bregister_t;
+/*
+ * if other persuasion endian, then compiler will probably require that
+ * these next
+ * macros be reversed
+ */
+#define	BTBYTE(what)	bregister_t  what:8; int :24
+#define	BTWORD(what)	bregister_t  what:16; int: 16
+#define BTLONG(what)	bregister_t  what:32
+
+struct bt848_registers {
+    BTBYTE (dstatus);		/* 0, 1,2,3 */
+#define BT848_DSTATUS_PRES		(1<<7)
+#define BT848_DSTATUS_HLOC		(1<<6)
+#define BT848_DSTATUS_FIELD		(1<<5)
+#define BT848_DSTATUS_NUML		(1<<4)
+#define BT848_DSTATUS_CSEL		(1<<3)
+#define BT848_DSTATUS_PLOCK		(1<<2)
+#define BT848_DSTATUS_LOF		(1<<1)
+#define BT848_DSTATUS_COF		(1<<0)
+    BTBYTE (iform);		/* 4, 5,6,7 */
+#define BT848_IFORM_MUXSEL		(0x3<<5)
+# define BT848_IFORM_M_MUX1		(0x03<<5)
+# define BT848_IFORM_M_MUX0		(0x02<<5)
+# define BT848_IFORM_M_MUX2		(0x01<<5)
+# define BT848_IFORM_M_MUX3		(0x0)
+# define BT848_IFORM_M_RSVD		(0x00<<5)
+#define BT848_IFORM_XTSEL		(0x3<<3)
+# define BT848_IFORM_X_AUTO		(0x03<<3)
+# define BT848_IFORM_X_XT1		(0x02<<3)
+# define BT848_IFORM_X_XT0		(0x01<<3)
+# define BT848_IFORM_X_RSVD		(0x00<<3)
+    BTBYTE (tdec);		/* 8, 9,a,b */
+    BTBYTE (e_crop);		/* c, d,e,f */
+    BTBYTE (e_vdelay_lo);	/* 10, 11,12,13 */
+    BTBYTE (e_vactive_lo);	/* 14, 15,16,17 */
+    BTBYTE (e_delay_lo);	/* 18, 19,1a,1b */
+    BTBYTE (e_hactive_lo);	/* 1c, 1d,1e,1f */
+    BTBYTE (e_hscale_hi);	/* 20, 21,22,23 */
+    BTBYTE (e_hscale_lo);	/* 24, 25,26,27 */
+    BTBYTE (bright);		/* 28, 29,2a,2b */
+    BTBYTE (e_control);		/* 2c, 2d,2e,2f */
+#define BT848_E_CONTROL_LNOTCH		(1<<7)
+#define BT848_E_CONTROL_COMP		(1<<6)
+#define BT848_E_CONTROL_LDEC		(1<<5)
+#define BT848_E_CONTROL_CBSENSE		(1<<4)
+#define BT848_E_CONTROL_RSVD		(1<<3)
+#define BT848_E_CONTROL_CON_MSB		(1<<2)
+#define BT848_E_CONTROL_SAT_U_MSB	(1<<1)
+#define BT848_E_CONTROL_SAT_V_MSB	(1<<0)
+    BTBYTE (contrast_lo);	/* 30, 31,32,33 */
+    BTBYTE (sat_u_lo);		/* 34, 35,36,37 */
+    BTBYTE (sat_v_lo);		/* 38, 39,3a,3b */
+    BTBYTE (hue);		/* 3c, 3d,3e,3f */
+    BTBYTE (e_scloop);		/* 40, 41,42,43 */
+#define BT848_E_SCLOOP_RSVD1		(1<<7)
+#define BT848_E_SCLOOP_CAGC		(1<<6)
+#define BT848_E_SCLOOP_CKILL		(1<<5)
+#define BT848_E_SCLOOP_HFILT		(0x3<<3)
+# define BT848_E_SCLOOP_HFILT_ICON	(0x3<<3)
+# define BT848_E_SCLOOP_HFILT_QCIF	(0x2<<3)
+# define BT848_E_SCLOOP_HFILT_CIF	(0x1<<3)
+# define BT848_E_SCLOOP_HFILT_AUTO	(0x0<<3)
+#define BT848_E_SCLOOP_RSVD0		(0x7<<0)
+    int		:32;		/* 44, 45,46,47 */
+    BTBYTE (oform);		/* 48, 49,4a,4b */
+    BTBYTE (e_vscale_hi);	/* 4c, 4d,4e,4f */
+    BTBYTE (e_vscale_lo);	/* 50, 51,52,53 */
+    BTBYTE (test);		/* 54, 55,56,57 */
+    int		:32;		/* 58, 59,5a,5b */
+    int		:32;		/* 5c, 5d,5e,5f */
+    BTLONG (adelay);		/* 60, 61,62,63 */
+    BTBYTE (bdelay);		/* 64, 65,66,67 */
+    BTBYTE (adc);		/* 68, 69,6a,6b */
+#define BT848_ADC_RESERVED		(0x80)	/* required pattern */
+#define BT848_ADC_SYNC_T		(1<<5)
+#define BT848_ADC_AGC_EN		(1<<4)
+#define BT848_ADC_CLK_SLEEP		(1<<3)
+#define BT848_ADC_Y_SLEEP		(1<<2)
+#define BT848_ADC_C_SLEEP		(1<<1)
+#define BT848_ADC_CRUSH			(1<<0)
+    BTBYTE (e_vtc);		/* 6c, 6d,6e,6f */
+    int		:32;		/* 70, 71,72,73 */
+    int 	:32;		/* 74, 75,76,77 */
+    int		:32;		/* 78, 79,7a,7b */
+    BTLONG (sreset);		/* 7c, 7d,7e,7f */
+    u_char 	filler1[0x84-0x80];
+    BTBYTE (tgctrl);		/* 84, 85,86,87 */
+#define BT848_TGCTRL_TGCKI		(3<<3)
+#define BT848_TGCTRL_TGCKI_XTAL		(0<<3)
+#define BT848_TGCTRL_TGCKI_PLL		(1<<3)
+#define BT848_TGCTRL_TGCKI_GPCLK	(2<<3)
+#define BT848_TGCTRL_TGCKI_GPCLK_I	(3<<3)
+    u_char 	filler[0x8c-0x88];
+    BTBYTE (o_crop);		/* 8c, 8d,8e,8f */
+    BTBYTE (o_vdelay_lo);	/* 90, 91,92,93 */
+    BTBYTE (o_vactive_lo);	/* 94, 95,96,97 */
+    BTBYTE (o_delay_lo);	/* 98, 99,9a,9b */
+    BTBYTE (o_hactive_lo);	/* 9c, 9d,9e,9f */
+    BTBYTE (o_hscale_hi);	/* a0, a1,a2,a3 */
+    BTBYTE (o_hscale_lo);	/* a4, a5,a6,a7 */
+    int		:32;		/* a8, a9,aa,ab */
+    BTBYTE (o_control);		/* ac, ad,ae,af */
+#define BT848_O_CONTROL_LNOTCH		(1<<7)
+#define BT848_O_CONTROL_COMP		(1<<6)
+#define BT848_O_CONTROL_LDEC		(1<<5)
+#define BT848_O_CONTROL_CBSENSE		(1<<4)
+#define BT848_O_CONTROL_RSVD		(1<<3)
+#define BT848_O_CONTROL_CON_MSB		(1<<2)
+#define BT848_O_CONTROL_SAT_U_MSB	(1<<1)
+#define BT848_O_CONTROL_SAT_V_MSB	(1<<0)
+    u_char	fillter4[16];
+    BTBYTE (o_scloop);		/* c0, c1,c2,c3 */
+#define BT848_O_SCLOOP_RSVD1		(1<<7)
+#define BT848_O_SCLOOP_CAGC		(1<<6)
+#define BT848_O_SCLOOP_CKILL		(1<<5)
+#define BT848_O_SCLOOP_HFILT		(0x3<<3)
+#define BT848_O_SCLOOP_HFILT_ICON	(0x3<<3)
+#define BT848_O_SCLOOP_HFILT_QCIF	(0x2<<3)
+#define BT848_O_SCLOOP_HFILT_CIF	(0x1<<3)
+#define BT848_O_SCLOOP_HFILT_AUTO	(0x0<<3)
+#define BT848_O_SCLOOP_RSVD0		(0x7<<0)
+    int		:32;		/* c4, c5,c6,c7 */
+    int		:32;		/* c8, c9,ca,cb */
+    BTBYTE (o_vscale_hi);	/* cc, cd,ce,cf */
+    BTBYTE (o_vscale_lo);	/* d0, d1,d2,d3 */
+    BTBYTE (color_fmt);		/* d4, d5,d6,d7 */
+    bregister_t color_ctl_swap		:4; /* d8 */
+#define BT848_COLOR_CTL_WSWAP_ODD	(1<<3)
+#define BT848_COLOR_CTL_WSWAP_EVEN	(1<<2)
+#define BT848_COLOR_CTL_BSWAP_ODD	(1<<1)
+#define BT848_COLOR_CTL_BSWAP_EVEN	(1<<0)
+    bregister_t color_ctl_gamma		:1;
+    bregister_t color_ctl_rgb_ded	:1;
+    bregister_t color_ctl_color_bars	:1;
+    bregister_t color_ctl_ext_frmrate	:1;
+#define BT848_COLOR_CTL_GAMMA		(1<<4)
+#define BT848_COLOR_CTL_RGB_DED		(1<<5)
+#define BT848_COLOR_CTL_COLOR_BARS	(1<<6)
+#define BT848_COLOR_CTL_EXT_FRMRATE     (1<<7)
+    int		:24;		/* d9,da,db */
+    BTBYTE (cap_ctl);		/* dc, dd,de,df */
+#define BT848_CAP_CTL_DITH_FRAME	(1<<4)
+#define BT848_CAP_CTL_VBI_ODD		(1<<3)
+#define BT848_CAP_CTL_VBI_EVEN		(1<<2)
+#define BT848_CAP_CTL_ODD		(1<<1)
+#define BT848_CAP_CTL_EVEN		(1<<0)
+    BTBYTE (vbi_pack_size);	/* e0, e1,e2,e3 */
+    BTBYTE (vbi_pack_del);	/* e4, e5,e6,e7 */
+    int		:32;		/* e8, e9,ea,eb */
+    BTBYTE (o_vtc);		/* ec, ed,ee,ef */
+    BTBYTE (pll_f_lo);		/* f0, f1,f2,f3 */
+    BTBYTE (pll_f_hi);		/* f4, f5,f6,f7 */
+    BTBYTE (pll_f_xci);		/* f8, f9,fa,fb */
+#define BT848_PLL_F_C			(1<<6)
+#define BT848_PLL_F_X			(1<<7)
+    u_char	filler2[0x100-0xfc];
+    BTLONG (int_stat);		/* 100, 101,102,103 */
+    BTLONG (int_mask);		/* 104, 105,106,107 */
+#define BT848_INT_RISCS			(0xf<<28)
+#define BT848_INT_RISC_EN		(1<<27)
+#define BT848_INT_RACK			(1<<25)
+#define BT848_INT_FIELD			(1<<24)
+#define BT848_INT_MYSTERYBIT		(1<<23)
+#define BT848_INT_SCERR			(1<<19)
+#define BT848_INT_OCERR			(1<<18)
+#define BT848_INT_PABORT		(1<<17)
+#define BT848_INT_RIPERR		(1<<16)
+#define BT848_INT_PPERR			(1<<15)
+#define BT848_INT_FDSR			(1<<14)
+#define BT848_INT_FTRGT			(1<<13)
+#define BT848_INT_FBUS			(1<<12)
+#define BT848_INT_RISCI			(1<<11)
+#define BT848_INT_GPINT			(1<<9)
+#define BT848_INT_I2CDONE		(1<<8)
+#define BT848_INT_RSV1			(1<<7)
+#define BT848_INT_RSV0			(1<<6)
+#define BT848_INT_VPRES			(1<<5)
+#define BT848_INT_HLOCK			(1<<4)
+#define BT848_INT_OFLOW			(1<<3)
+#define BT848_INT_HSYNC			(1<<2)
+#define BT848_INT_VSYNC			(1<<1)
+#define BT848_INT_FMTCHG		(1<<0)
+    int		:32;		/* 108, 109,10a,10b */
+    BTWORD (gpio_dma_ctl);	/* 10c, 10d,10e,10f */
+#define BT848_DMA_CTL_PL23TP4		(0<<6)	/* planar1 trigger 4 */
+#define BT848_DMA_CTL_PL23TP8		(1<<6)	/* planar1 trigger 8 */
+#define BT848_DMA_CTL_PL23TP16		(2<<6)	/* planar1 trigger 16 */
+#define BT848_DMA_CTL_PL23TP32		(3<<6)	/* planar1 trigger 32 */
+#define BT848_DMA_CTL_PL1TP4		(0<<4)	/* planar1 trigger 4 */
+#define BT848_DMA_CTL_PL1TP8		(1<<4)	/* planar1 trigger 8 */
+#define BT848_DMA_CTL_PL1TP16		(2<<4)	/* planar1 trigger 16 */
+#define BT848_DMA_CTL_PL1TP32		(3<<4)	/* planar1 trigger 32 */
+#define BT848_DMA_CTL_PKTP4		(0<<2)	/* packed trigger 4 */
+#define BT848_DMA_CTL_PKTP8		(1<<2)	/* packed trigger 8 */
+#define BT848_DMA_CTL_PKTP16		(2<<2)	/* packed trigger 16 */
+#define BT848_DMA_CTL_PKTP32		(3<<2)	/* packed trigger 32 */
+#define BT848_DMA_CTL_RISC_EN		(1<<1)
+#define BT848_DMA_CTL_FIFO_EN		(1<<0)
+    BTLONG (i2c_data_ctl);	/* 110, 111,112,113 */
+#define BT848_DATA_CTL_I2CDIV		(0xf<<4)
+#define BT848_DATA_CTL_I2CSYNC		(1<<3)
+#define BT848_DATA_CTL_I2CW3B		(1<<2)
+#define BT848_DATA_CTL_I2CSCL		(1<<1)
+#define BT848_DATA_CTL_I2CSDA		(1<<0)
+    BTLONG (risc_strt_add);	/* 114, 115,116,117 */
+    BTLONG (gpio_out_en);	/* 118, 119,11a,11b */	/* really 24 bits */
+    BTLONG (gpio_reg_inp);	/* 11c, 11d,11e,11f */	/* really 24 bits */
+    BTLONG (risc_count);	/* 120, 121,122,123 */
+    u_char	filler3[0x200-0x124];
+    BTLONG (gpio_data);		/* 200, 201,202,203 */	/* really 24 bits */
+};
+
+
+#define BKTR_DSTATUS			0x000
+#define BKTR_IFORM			0x004
+#define BKTR_TDEC			0x008
+#define BKTR_E_CROP			0x00C
+#define BKTR_O_CROP			0x08C
+#define BKTR_E_VDELAY_LO		0x010
+#define BKTR_O_VDELAY_LO		0x090
+#define BKTR_E_VACTIVE_LO		0x014
+#define BKTR_O_VACTIVE_LO		0x094
+#define BKTR_E_DELAY_LO			0x018
+#define BKTR_O_DELAY_LO			0x098
+#define BKTR_E_HACTIVE_LO		0x01C
+#define BKTR_O_HACTIVE_LO		0x09C
+#define BKTR_E_HSCALE_HI		0x020
+#define BKTR_O_HSCALE_HI		0x0A0
+#define BKTR_E_HSCALE_LO		0x024
+#define BKTR_O_HSCALE_LO		0x0A4
+#define BKTR_BRIGHT			0x028
+#define BKTR_E_CONTROL			0x02C
+#define BKTR_O_CONTROL			0x0AC
+#define BKTR_CONTRAST_LO		0x030
+#define BKTR_SAT_U_LO			0x034
+#define BKTR_SAT_V_LO			0x038
+#define BKTR_HUE			0x03C
+#define BKTR_E_SCLOOP			0x040
+#define BKTR_O_SCLOOP			0x0C0
+#define BKTR_OFORM			0x048
+#define BKTR_E_VSCALE_HI		0x04C
+#define BKTR_O_VSCALE_HI		0x0CC
+#define BKTR_E_VSCALE_LO		0x050
+#define BKTR_O_VSCALE_LO		0x0D0
+#define BKTR_TEST			0x054
+#define BKTR_ADELAY			0x060
+#define BKTR_BDELAY			0x064
+#define BKTR_ADC			0x068
+#define BKTR_E_VTC			0x06C
+#define BKTR_O_VTC			0x0EC
+#define BKTR_SRESET			0x07C
+#define BKTR_COLOR_FMT			0x0D4
+#define BKTR_COLOR_CTL			0x0D8
+#define BKTR_CAP_CTL			0x0DC
+#define BKTR_VBI_PACK_SIZE		0x0E0
+#define BKTR_VBI_PACK_DEL		0x0E4
+#define BKTR_INT_STAT			0x100
+#define BKTR_INT_MASK			0x104
+#define BKTR_RISC_COUNT			0x120
+#define BKTR_RISC_STRT_ADD		0x114
+#define BKTR_GPIO_DMA_CTL		0x10C
+#define BKTR_GPIO_OUT_EN		0x118
+#define BKTR_GPIO_REG_INP		0x11C
+#define BKTR_GPIO_DATA			0x200
+#define BKTR_I2C_DATA_CTL		0x110
+#define BKTR_TGCTRL			0x084
+#define BKTR_PLL_F_LO			0x0F0 
+#define BKTR_PLL_F_HI			0x0F4 
+#define BKTR_PLL_F_XCI			0x0F8
+
+/*
+ * device support for onboard tv tuners
+ */
+
+/* description of the LOGICAL tuner */
+struct TVTUNER {
+	int		frequency;
+	u_char		chnlset;
+	u_char		channel;
+	u_char		band;
+	u_char		afc;
+ 	u_char		radio_mode;	/* current mode of the radio mode */
+};
+
+/* description of the PHYSICAL tuner */
+struct TUNER {
+	char*		name;
+	u_char		type;
+	u_char		pllControl[4];
+	u_char		bandLimits[ 2 ];
+	u_char		bandAddrs[ 4 ];        /* 3 first for the 3 TV 
+					       ** bands. Last for radio 
+					       ** band (0x00=NoRadio).
+					       */
+
+};
+
+/* description of the card */
+#define EEPROMBLOCKSIZE		32
+struct CARDTYPE {
+	unsigned int		card_id;	/* card id (from #define's) */
+	char*			name;
+	const struct TUNER*	tuner;		/* Tuner details */
+	u_char			tuner_pllAddr;	/* Tuner i2c address */
+	u_char			dbx;		/* Has DBX chip? */
+	u_char			msp3400c;	/* Has msp3400c chip? */
+	u_char			dpl3518a;	/* Has dpl3518a chip? */
+	u_char			eepromAddr;
+	u_char			eepromSize;	/* bytes / EEPROMBLOCKSIZE */
+	u_int			audiomuxs[ 5 ];	/* tuner, ext (line-in) */
+						/* int/unused (radio) */
+						/* mute, present */
+	u_int			gpio_mux_bits;	/* GPIO mask for audio mux */
+};
+
+struct format_params {
+  /* Total lines, lines before image, image lines */
+  int vtotal, vdelay, vactive;
+  /* Total unscaled horizontal pixels, pixels before image, image pixels */
+  int htotal, hdelay, hactive;
+  /* Scaled horizontal image pixels, Total Scaled horizontal pixels */
+  int  scaled_hactive, scaled_htotal;
+  /* frame rate . for ntsc is 30 frames per second */
+  int frame_rate;
+  /* A-delay and B-delay */
+  u_char adelay, bdelay;
+  /* Iform XTSEL value */
+  int iform_xtsel;
+  /* VBI number of lines per field, and number of samples per line */
+  int vbi_num_lines, vbi_num_samples;
+};
+
+#if defined(BKTR_USE_FREEBSD_SMBUS)
+struct bktr_i2c_softc {
+	device_t iicbus;
+	device_t smbus;
+};
+#endif
+
+
+/* Bt848/878 register access
+ * The registers can either be access via a memory mapped structure
+ * or accessed via bus_space.
+ * bus_0pace access allows cross platform support, where as the
+ * memory mapped structure method only works on 32 bit processors
+ * with the right type of endianness.
+ */
+#if defined(__NetBSD__) || ( defined(__FreeBSD__) && (__FreeBSD_version >=300000) )
+#define INB(bktr,offset)	bus_space_read_1((bktr)->memt,(bktr)->memh,(offset))
+#define INW(bktr,offset)	bus_space_read_2((bktr)->memt,(bktr)->memh,(offset))
+#define INL(bktr,offset)	bus_space_read_4((bktr)->memt,(bktr)->memh,(offset))
+#define OUTB(bktr,offset,value) bus_space_write_1((bktr)->memt,(bktr)->memh,(offset),(value))
+#define OUTW(bktr,offset,value) bus_space_write_2((bktr)->memt,(bktr)->memh,(offset),(value))
+#define OUTL(bktr,offset,value) bus_space_write_4((bktr)->memt,(bktr)->memh,(offset),(value))
+#else
+#define INB(bktr,offset)	*(volatile unsigned char*) ((int)((bktr)->memh)+(offset))
+#define INW(bktr,offset)	*(volatile unsigned short*)((int)((bktr)->memh)+(offset))
+#define INL(bktr,offset)	*(volatile unsigned int*)  ((int)((bktr)->memh)+(offset))
+#define OUTB(bktr,offset,value)	*(volatile unsigned char*) ((int)((bktr)->memh)+(offset)) = (value)
+#define OUTW(bktr,offset,value)	*(volatile unsigned short*)((int)((bktr)->memh)+(offset)) = (value)
+#define OUTL(bktr,offset,value)	*(volatile unsigned int*)  ((int)((bktr)->memh)+(offset)) = (value)
+#endif
+
+
+typedef struct bktr_clip bktr_clip_t;
+
+/*
+ * BrookTree 848  info structure, one per bt848 card installed.
+ */
+struct bktr_softc {
+
+#if defined (__bsdi__)
+    struct device bktr_dev;	/* base device */
+    struct isadev bktr_id;	/* ISA device */
+    struct intrhand bktr_ih;	/* interrupt vectoring */
+    #define pcici_t pci_devaddr_t
+#endif
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+    struct device bktr_dev;     /* base device */
+    bus_dma_tag_t	dmat;   /* DMA tag */
+    bus_space_tag_t	memt;
+    bus_space_handle_t	memh;
+    bus_size_t		obmemsz;        /* size of en card (bytes) */
+    void		*ih;
+    bus_dmamap_t	dm_prog;
+    bus_dmamap_t	dm_oprog;
+    bus_dmamap_t	dm_mem;
+    bus_dmamap_t	dm_vbidata;
+    bus_dmamap_t	dm_vbibuffer;
+#ifdef __OpenBSD__
+    size_t		dm_mapsize;
+#endif
+#endif
+
+#if defined (__FreeBSD__)
+    #if (__FreeBSD_version < 400000)
+    vm_offset_t     phys_base;	/* 2.x Bt848 register physical address */
+    pcici_t         tag;	/* 2.x PCI tag, for doing PCI commands */
+    #endif
+    #if (__FreeBSD_version >= 400000)
+    int             mem_rid;	/* 4.x resource id */
+    struct resource *res_mem;	/* 4.x resource descriptor for registers */
+    int             irq_rid;	/* 4.x resource id */
+    struct resource *res_irq;	/* 4.x resource descriptor for interrupt */
+    void            *res_ih;	/* 4.x newbus interrupt handler cookie */
+    dev_t           bktrdev;	/* 4.x device entry for /dev/bktrN */
+    dev_t           tunerdev;	/* 4.x device entry for /dev/tunerN */
+    dev_t           vbidev;	/* 4.x device entry for /dev/vbiN */
+    dev_t           bktrdev_alias;	/* alias /dev/bktr to /dev/bktr0 */
+    dev_t           tunerdev_alias;	/* alias /dev/tuner to /dev/tuner0 */
+    dev_t           vbidev_alias;	/* alias /dev/vbi to /dev/vbi0 */
+    #endif
+    #if (__FreeBSD_version >= 310000)
+    bus_space_tag_t	memt;	/* Bus space register access functions */
+    bus_space_handle_t	memh;	/* Bus space register access functions */
+    bus_size_t		obmemsz;/* Size of card (bytes) */
+    #endif
+    #if (NSMBUS > 0)
+      struct bktr_i2c_softc i2c_sc;	/* bt848_i2c device */
+    #endif
+    char	bktr_xname[7];	/* device name and unit number */
+#endif
+
+
+    /* The following definitions are for the contiguous memory */
+#ifdef __NetBSD__
+    vaddr_t bigbuf;          /* buffer that holds the captured image */
+    vaddr_t vbidata;         /* RISC program puts VBI data from the current frame here */
+    vaddr_t vbibuffer;       /* Circular buffer holding VBI data for the user */
+    vaddr_t dma_prog;        /* RISC prog for single and/or even field capture*/
+    vaddr_t odd_dma_prog;    /* RISC program for Odd field capture */
+#else
+    vm_offset_t bigbuf;	     /* buffer that holds the captured image */
+    vm_offset_t vbidata;     /* RISC program puts VBI data from the current frame here */
+    vm_offset_t vbibuffer;   /* Circular buffer holding VBI data for the user */
+    vm_offset_t dma_prog;    /* RISC prog for single and/or even field capture*/
+    vm_offset_t odd_dma_prog;/* RISC program for Odd field capture */
+#endif
+
+
+    /* the following definitions are common over all platforms */
+    int		alloc_pages;	/* number of pages in bigbuf */
+    int         vbiinsert;      /* Position for next write into circular buffer */
+    int         vbistart;       /* Position of last read from circular buffer */
+    int         vbisize;        /* Number of bytes in the circular buffer */
+    u_long	vbi_sequence_number;	/* sequence number for VBI */
+    int		vbi_read_blocked;	/* user process blocked on read() from /dev/vbi */
+    struct selinfo vbi_select;	/* Data used by select() on /dev/vbi */
+    
+
+    struct proc	*proc;		/* process to receive raised signal */
+    int		signal;		/* signal to send to process */
+    int		clr_on_start;	/* clear cap buf on capture start? */
+#define	METEOR_SIG_MODE_MASK	0xffff0000
+#define	METEOR_SIG_FIELD_MODE	0x00010000
+#define	METEOR_SIG_FRAME_MODE	0x00000000
+    char         dma_prog_loaded;
+    struct meteor_mem *mem;	/* used to control sync. multi-frame output */
+    u_long	synch_wait;	/* wait for free buffer before continuing */
+    short	current;	/* frame number in buffer (1-frames) */
+    short	rows;		/* number of rows in a frame */
+    short	cols;		/* number of columns in a frame */
+    int		capture_area_x_offset; /* Usually the full 640x480(NTSC) image is */
+    int		capture_area_y_offset; /* captured. The capture area allows for */
+    int		capture_area_x_size;   /* example 320x200 pixels from the centre */
+    int		capture_area_y_size;   /* of the video image to be captured. */
+    char	capture_area_enabled;  /* When TRUE use user's capture area. */
+    int		pixfmt;         /* active pixel format (idx into fmt tbl) */
+    int		pixfmt_compat;  /* Y/N - in meteor pix fmt compat mode */
+    u_long	format;		/* frame format rgb, yuv, etc.. */
+    short	frames;		/* number of frames allocated */
+    int		frame_size;	/* number of bytes in a frame */
+    u_long	fifo_errors;	/* number of fifo capture errors since open */
+    u_long	dma_errors;	/* number of DMA capture errors since open */
+    u_long	frames_captured;/* number of frames captured since open */
+    u_long	even_fields_captured; /* number of even fields captured */
+    u_long	odd_fields_captured; /* number of odd fields captured */
+    u_long	range_enable;	/* enable range checking ?? */
+    u_short     capcontrol;     /* reg 0xdc capture control */
+    u_short     bktr_cap_ctl;
+    volatile u_int	flags;
+#define	METEOR_INITALIZED	0x00000001
+#define	METEOR_OPEN		0x00000002 
+#define	METEOR_MMAP		0x00000004
+#define	METEOR_INTR		0x00000008
+#define	METEOR_READ		0x00000010	/* XXX never gets referenced */
+#define	METEOR_SINGLE		0x00000020	/* get single frame */
+#define	METEOR_CONTIN		0x00000040	/* continuously get frames */
+#define	METEOR_SYNCAP		0x00000080	/* synchronously get frames */
+#define	METEOR_CAP_MASK		0x000000f0
+#define	METEOR_NTSC		0x00000100
+#define	METEOR_PAL		0x00000200
+#define	METEOR_SECAM		0x00000400
+#define	BROOKTREE_NTSC		0x00000100	/* used in video open() and */
+#define	BROOKTREE_PAL		0x00000200	/* in the kernel config */
+#define	BROOKTREE_SECAM		0x00000400	/* file */
+#define	METEOR_AUTOMODE		0x00000800
+#define	METEOR_FORM_MASK	0x00000f00
+#define	METEOR_DEV0		0x00001000
+#define	METEOR_DEV1		0x00002000
+#define	METEOR_DEV2		0x00004000
+#define	METEOR_DEV3		0x00008000
+#define METEOR_DEV_SVIDEO	0x00006000
+#define METEOR_DEV_RGB		0x0000a000
+#define	METEOR_DEV_MASK		0x0000f000
+#define	METEOR_RGB16		0x00010000
+#define	METEOR_RGB24		0x00020000
+#define	METEOR_YUV_PACKED	0x00040000
+#define	METEOR_YUV_PLANAR	0x00080000
+#define	METEOR_WANT_EVEN	0x00100000	/* want even frame */
+#define	METEOR_WANT_ODD		0x00200000	/* want odd frame */
+#define	METEOR_WANT_MASK	0x00300000
+#define METEOR_ONLY_EVEN_FIELDS	0x01000000
+#define METEOR_ONLY_ODD_FIELDS	0x02000000
+#define METEOR_ONLY_FIELDS_MASK 0x03000000
+#define METEOR_YUV_422		0x04000000
+#define	METEOR_OUTPUT_FMT_MASK	0x040f0000
+#define	METEOR_WANT_TS		0x08000000	/* time-stamp a frame */
+#define METEOR_RGB		0x20000000	/* meteor rgb unit */
+#define METEOR_FIELD_MODE	0x80000000
+    u_char	tflags;				/* Tuner flags (/dev/tuner) */
+#define	TUNER_INITALIZED	0x00000001
+#define	TUNER_OPEN		0x00000002 
+    u_char      vbiflags;			/* VBI flags (/dev/vbi) */
+#define VBI_INITALIZED          0x00000001
+#define VBI_OPEN                0x00000002
+#define VBI_CAPTURE             0x00000004
+    u_short	fps;		/* frames per second */
+    struct meteor_video video;
+    struct TVTUNER	tuner;
+    struct CARDTYPE	card;
+    u_char		audio_mux_select;	/* current mode of the audio */
+    u_char		audio_mute_state;	/* mute state of the audio */
+    u_char		format_params;
+    u_long              current_sol;
+    u_long              current_col;
+    int                 clip_start;
+    int                 line_length;
+    int                 last_y;
+    int                 y;
+    int                 y2;
+    int                 yclip;
+    int                 yclip2;
+    int                 max_clip_node;
+    bktr_clip_t		clip_list[100];
+    int                 reverse_mute;		/* Swap the GPIO values for Mute and TV Audio */
+    int                 bt848_tuner;
+    int                 bt848_card;
+    u_long              id;
+#define BT848_USE_XTALS 0
+#define BT848_USE_PLL   1
+    int			xtal_pll_mode;	/* Use XTAL or PLL mode for PAL/SECAM */
+    int			remote_control;      /* remote control detected */
+    int			remote_control_addr;   /* remote control i2c address */
+    char		msp_version_string[9]; /* MSP version string 34xxx-xx */
+    int			msp_addr;	       /* MSP i2c address */
+    char		dpl_version_string[9]; /* DPL version string 35xxx-xx */
+    int			dpl_addr;	       /* DPL i2c address */
+    int                 slow_msp_audio;	       /* 0 = use fast MSP3410/3415 programming sequence */
+					       /* 1 = use slow MSP3410/3415 programming sequence */
+					       /* 2 = use Tuner's Mono audio output via the MSP chip */
+    int                 msp_use_mono_source;   /* use Tuner's Mono audio output via the MSP chip */
+    int                 audio_mux_present;     /* 1 = has audio mux on GPIO lines, 0 = no audio mux */
+    int                 msp_source_selected;   /* 0 = TV source, 1 = Line In source, 2 = FM Radio Source */
+
+};
+
+typedef struct bktr_softc bktr_reg_t;
+typedef struct bktr_softc* bktr_ptr_t;
+
+#define Bt848_MAX_SIGN 16
+
+struct bt848_card_sig {
+  int card;
+  int tuner;
+  u_char signature[Bt848_MAX_SIGN];
+};
+
+
+/***********************************************************/
+/* ioctl_cmd_t int on old versions, u_long on new versions */
+/***********************************************************/
+
+#if (__FreeBSD__ == 2)
+typedef int ioctl_cmd_t;
+#endif
+
+#if defined(__FreeBSD__)
+#if (__FreeBSD_version >= 300000)
+typedef u_long ioctl_cmd_t;
+#endif
+#endif
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+typedef u_long ioctl_cmd_t;
+#endif
+
+
diff --git a/sys/dev/pci/bktr/bktr_tuner.c b/sys/dev/pci/bktr/bktr_tuner.c
new file mode 100644
index 00000000000..e4b2fd3c998
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_tuner.c
@@ -0,0 +1,1017 @@
+/*	$OpenBSD: bktr_tuner.c,v 1.1 2001/03/28 03:27:10 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_tuner.c,v 1.9 2000/10/19 07:33:28 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ *
+ * bktr_tuner : This deals with controlling the tuner fitted to TV cards.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/vnode.h>
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/proc.h>
+#endif
+
+#ifdef __FreeBSD__
+#include <pci/pcivar.h>
+
+#if (__FreeBSD_version < 500000)
+#include <machine/clock.h>              /* for DELAY */
+#endif
+
+#if (__FreeBSD_version >=300000)
+#include <machine/bus_memio.h>          /* for bus space */
+#include <machine/bus.h>
+#include <sys/bus.h>
+#endif
+#endif
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <dev/ic/bt8xx.h>	/* NetBSD .h file location */
+#include <dev/pci/bktr/bktr_reg.h>
+#include <dev/pci/bktr/bktr_tuner.h>
+#include <dev/pci/bktr/bktr_card.h>
+#include <dev/pci/bktr/bktr_core.h>
+#else
+#include <machine/ioctl_meteor.h>	/* Traditional .h file location */
+#include <machine/ioctl_bt848.h>        /* extensions to ioctl_meteor.h */
+#include <dev/bktr/bktr_reg.h>
+#include <dev/bktr/bktr_tuner.h>
+#include <dev/bktr/bktr_card.h>
+#include <dev/bktr/bktr_core.h>
+#endif
+
+
+
+#if defined( TUNER_AFC )
+#define AFC_DELAY               10000   /* 10 millisend delay */
+#define AFC_BITS                0x07
+#define AFC_FREQ_MINUS_125      0x00
+#define AFC_FREQ_MINUS_62       0x01
+#define AFC_FREQ_CENTERED       0x02
+#define AFC_FREQ_PLUS_62        0x03
+#define AFC_FREQ_PLUS_125       0x04
+#define AFC_MAX_STEP            (5 * FREQFACTOR) /* no more than 5 MHz */
+#endif /* TUNER_AFC */
+
+  
+#define TTYPE_XXX               0
+#define TTYPE_NTSC              1
+#define TTYPE_NTSC_J            2
+#define TTYPE_PAL               3
+#define TTYPE_PAL_M             4
+#define TTYPE_PAL_N             5
+#define TTYPE_SECAM             6
+  
+#define TSA552x_CB_MSB          (0x80)
+#define TSA552x_CB_CP           (1<<6)	/* set this for fast tuning */
+#define TSA552x_CB_T2           (1<<5)	/* test mode - Normally set to 0 */
+#define TSA552x_CB_T1           (1<<4)	/* test mode - Normally set to 0 */
+#define TSA552x_CB_T0           (1<<3)	/* test mode - Normally set to 1 */
+#define TSA552x_CB_RSA          (1<<2)	/* 0 for 31.25 khz, 1 for 62.5 kHz */
+#define TSA552x_CB_RSB          (1<<1)	/* 0 for FM 50kHz steps, 1 = Use RSA*/
+#define TSA552x_CB_OS           (1<<0)	/* Set to 0 for normal operation */
+
+#define TSA552x_RADIO           (TSA552x_CB_MSB |       \
+                                 TSA552x_CB_T0)
+
+/* raise the charge pump voltage for fast tuning */
+#define TSA552x_FCONTROL        (TSA552x_CB_MSB |       \
+                                 TSA552x_CB_CP  |       \
+                                 TSA552x_CB_T0  |       \
+                                 TSA552x_CB_RSA |       \
+                                 TSA552x_CB_RSB)
+  
+/* lower the charge pump voltage for better residual oscillator FM */
+#define TSA552x_SCONTROL        (TSA552x_CB_MSB |       \
+                                 TSA552x_CB_T0  |       \
+                                 TSA552x_CB_RSA |       \
+                                 TSA552x_CB_RSB)
+  
+/* The control value for the ALPS TSCH5 Tuner */
+#define TSCH5_FCONTROL          0x82
+#define TSCH5_RADIO             0x86
+  
+/* The control value for the ALPS TSBH1 Tuner */
+#define TSBH1_FCONTROL		0xce
+
+
+static const struct TUNER tuners[] = {
+/* XXX FIXME: fill in the band-switch crosspoints */
+	/* NO_TUNER */
+	{ "<no>",				/* the 'name' */
+	   TTYPE_XXX,				/* input type */
+ 	   { 0x00,				/* control byte for Tuner PLL */
+ 	     0x00,
+ 	     0x00,
+ 	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0x00, 0x00, 0x00,0x00} },		/* the band-switch values */
+
+	/* TEMIC_NTSC */
+	{ "Temic NTSC",				/* the 'name' */
+	   TTYPE_NTSC,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00},			/* band-switch crosspoints */
+	   { 0x02, 0x04, 0x01, 0x00 } },	/* the band-switch values */
+
+	/* TEMIC_PAL */
+	{ "Temic PAL",				/* the 'name' */
+	   TTYPE_PAL,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0x02, 0x04, 0x01, 0x00 } },	/* the band-switch values */
+
+	/* TEMIC_SECAM */
+	{ "Temic SECAM",			/* the 'name' */
+	   TTYPE_SECAM,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0x02, 0x04, 0x01,0x00 } },		/* the band-switch values */
+
+	/* PHILIPS_NTSC */
+	{ "Philips NTSC",			/* the 'name' */
+	   TTYPE_NTSC,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0xa0, 0x90, 0x30, 0x00 } },	/* the band-switch values */
+
+	/* PHILIPS_PAL */
+	{ "Philips PAL",			/* the 'name' */
+	   TTYPE_PAL,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0xa0, 0x90, 0x30, 0x00 } },	/* the band-switch values */
+
+	/* PHILIPS_SECAM */
+	{ "Philips SECAM",			/* the 'name' */
+	   TTYPE_SECAM,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0xa7, 0x97, 0x37, 0x00 } },	/* the band-switch values */
+
+	/* TEMIC_PAL I */
+	{ "Temic PAL I",			/* the 'name' */
+	   TTYPE_PAL,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0x02, 0x04, 0x01,0x00 } },		/* the band-switch values */
+
+	/* PHILIPS_PALI */
+	{ "Philips PAL I",			/* the 'name' */
+	   TTYPE_PAL,				/* input type */
+	   { TSA552x_SCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_SCONTROL,
+	     TSA552x_SCONTROL,
+	     0x00 },
+          { 0x00, 0x00 },                      /* band-switch crosspoints */
+          { 0xa0, 0x90, 0x30,0x00 } },         /* the band-switch values */
+
+       /* PHILIPS_FR1236_NTSC */
+       { "Philips FR1236 NTSC FM",             /* the 'name' */
+          TTYPE_NTSC,                          /* input type */
+	  { TSA552x_FCONTROL,			/* control byte for Tuner PLL */
+	    TSA552x_FCONTROL,
+	    TSA552x_FCONTROL,
+	    TSA552x_RADIO  },
+          { 0x00, 0x00 },			/* band-switch crosspoints */
+	  { 0xa0, 0x90, 0x30,0xa4 } },		/* the band-switch values */
+
+	/* PHILIPS_FR1216_PAL */
+	{ "Philips FR1216 PAL FM" ,		/* the 'name' */
+	   TTYPE_PAL,				/* input type */
+	   { TSA552x_FCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_FCONTROL,
+	     TSA552x_FCONTROL,
+	     TSA552x_RADIO },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0xa0, 0x90, 0x30, 0xa4 } },	/* the band-switch values */
+
+	/* PHILIPS_FR1236_SECAM */
+	{ "Philips FR1236 SECAM FM",		/* the 'name' */
+	   TTYPE_SECAM,				/* input type */
+	   { TSA552x_FCONTROL,			/* control byte for Tuner PLL */
+	     TSA552x_FCONTROL,
+	     TSA552x_FCONTROL,
+	     TSA552x_RADIO },
+	   { 0x00, 0x00 },			/* band-switch crosspoints */
+	   { 0xa7, 0x97, 0x37, 0xa4 } },	/* the band-switch values */
+
+        /* ALPS TSCH5 NTSC */
+        { "ALPS TSCH5 NTSC FM",                 /* the 'name' */
+           TTYPE_NTSC,                          /* input type */
+           { TSCH5_FCONTROL,                    /* control byte for Tuner PLL */
+             TSCH5_FCONTROL,
+             TSCH5_FCONTROL,
+             TSCH5_RADIO },
+           { 0x00, 0x00 },                      /* band-switch crosspoints */
+           { 0x14, 0x12, 0x11, 0x04 } },        /* the band-switch values */
+
+        /* ALPS TSBH1 NTSC */
+        { "ALPS TSBH1 NTSC",                    /* the 'name' */
+           TTYPE_NTSC,                          /* input type */
+           { TSBH1_FCONTROL,                    /* control byte for Tuner PLL */
+             TSBH1_FCONTROL,
+             TSBH1_FCONTROL,
+             0x00 },
+           { 0x00, 0x00 },                      /* band-switch crosspoints */
+           { 0x01, 0x02, 0x08, 0x00 } }         /* the band-switch values */
+};
+
+
+/* scaling factor for frequencies expressed as ints */
+#define FREQFACTOR		16
+
+/*
+ * Format:
+ *	entry 0:         MAX legal channel
+ *	entry 1:         IF frequency
+ *			 expressed as fi{mHz} * 16,
+ *			 eg 45.75mHz == 45.75 * 16 = 732
+ *	entry 2:         [place holder/future]
+ *	entry 3:         base of channel record 0
+ *	entry 3 + (x*3): base of channel record 'x'
+ *	entry LAST:      NULL channel entry marking end of records
+ *
+ * Record:
+ *	int 0:		base channel
+ *	int 1:		frequency of base channel,
+ *			 expressed as fb{mHz} * 16,
+ *	int 2:		offset frequency between channels,
+ *			 expressed as fo{mHz} * 16,
+ */
+
+/*
+ * North American Broadcast Channels:
+ *
+ *  2:  55.25 mHz -  4:  67.25 mHz
+ *  5:  77.25 mHz -  6:	 83.25 mHz
+ *  7: 175.25 mHz - 13:	211.25 mHz
+ * 14: 471.25 mHz - 83:	885.25 mHz
+ *
+ * IF freq: 45.75 mHz
+ */
+#define OFFSET	6.00
+static int nabcst[] = {
+	83,	(int)( 45.75 * FREQFACTOR),	0,
+	14,	(int)(471.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 7,	(int)(175.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 5,	(int)( 77.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 2,	(int)( 55.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 0
+};
+#undef OFFSET
+
+/*
+ * North American Cable Channels, IRC:
+ *
+ *  2:  55.25 mHz -  4:  67.25 mHz
+ *  5:  77.25 mHz -  6:  83.25 mHz
+ *  7: 175.25 mHz - 13: 211.25 mHz
+ * 14: 121.25 mHz - 22: 169.25 mHz
+ * 23: 217.25 mHz - 94: 643.25 mHz
+ * 95:  91.25 mHz - 99: 115.25 mHz
+ *
+ * IF freq: 45.75 mHz
+ */
+#define OFFSET	6.00
+static int irccable[] = {
+	116,    (int)( 45.75 * FREQFACTOR),     0,
+	100,    (int)(649.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	95,	(int)( 91.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	23,	(int)(217.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	14,	(int)(121.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 7,	(int)(175.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 5,	(int)( 77.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 2,	(int)( 55.25 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	 0
+};
+#undef OFFSET
+
+/*
+ * North American Cable Channels, HRC:
+ *
+ * 2:   54 mHz  - 4:    66 mHz
+ * 5:   78 mHz  - 6:    84 mHz
+ * 7:  174 mHz  - 13:  210 mHz
+ * 14: 120 mHz  - 22:  168 mHz
+ * 23: 216 mHz  - 94:  642 mHz
+ * 95:  90 mHz  - 99:  114 mHz
+ *
+ * IF freq: 45.75 mHz
+ */
+#define OFFSET  6.00
+static int hrccable[] = {
+	116,    (int)( 45.75 * FREQFACTOR),     0,
+	100,    (int)(648.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	95,	(int)( 90.00 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	23,	(int)(216.00 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	14,	(int)(120.00 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	7,	(int)(174.00 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	5,	(int)( 78.00 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	2,	(int)( 54.00 * FREQFACTOR),	(int)(OFFSET * FREQFACTOR),
+	0
+};
+#undef OFFSET
+
+/*
+ * Western European broadcast channels:
+ *
+ * (there are others that appear to vary between countries - rmt)
+ *
+ * here's the table Philips provides:
+ * caution, some of the offsets don't compute...
+ *
+ *  1	 4525	700	N21
+ * 
+ *  2	 4825	700	E2
+ *  3	 5525	700	E3
+ *  4	 6225	700	E4
+ * 
+ *  5	17525	700	E5
+ *  6	18225	700	E6
+ *  7	18925	700	E7
+ *  8	19625	700	E8
+ *  9	20325	700	E9
+ * 10	21025	700	E10
+ * 11	21725	700	E11
+ * 12	22425	700	E12
+ * 
+ * 13	 5375	700	ITA
+ * 14	 6225	700	ITB
+ * 
+ * 15	 8225	700	ITC
+ * 
+ * 16	17525	700	ITD
+ * 17	18325	700	ITE
+ * 
+ * 18	19225	700	ITF
+ * 19	20125	700	ITG
+ * 20	21025	700	ITH
+ * 
+ * 21	47125	800	E21
+ * 22	47925	800	E22
+ * 23	48725	800	E23
+ * 24	49525	800	E24
+ * 25	50325	800	E25
+ * 26	51125	800	E26
+ * 27	51925	800	E27
+ * 28	52725	800	E28
+ * 29	53525	800	E29
+ * 30	54325	800	E30
+ * 31	55125	800	E31
+ * 32	55925	800	E32
+ * 33	56725	800	E33
+ * 34	57525	800	E34
+ * 35	58325	800	E35
+ * 36	59125	800	E36
+ * 37	59925	800	E37
+ * 38	60725	800	E38
+ * 39	61525	800	E39
+ * 40	62325	800	E40
+ * 41	63125	800	E41
+ * 42	63925	800	E42
+ * 43	64725	800	E43
+ * 44	65525	800	E44
+ * 45	66325	800	E45
+ * 46	67125	800	E46
+ * 47	67925	800	E47
+ * 48	68725	800	E48
+ * 49	69525	800	E49
+ * 50	70325	800	E50
+ * 51	71125	800	E51
+ * 52	71925	800	E52
+ * 53	72725	800	E53
+ * 54	73525	800	E54
+ * 55	74325	800	E55
+ * 56	75125	800	E56
+ * 57	75925	800	E57
+ * 58	76725	800	E58
+ * 59	77525	800	E59
+ * 60	78325	800	E60
+ * 61	79125	800	E61
+ * 62	79925	800	E62
+ * 63	80725	800	E63
+ * 64	81525	800	E64
+ * 65	82325	800	E65
+ * 66	83125	800	E66
+ * 67	83925	800	E67
+ * 68	84725	800	E68
+ * 69	85525	800	E69
+ * 
+ * 70	 4575	800	IA
+ * 71	 5375	800	IB
+ * 72	 6175	800	IC
+ * 
+ * 74	 6925	700	S01
+ * 75	 7625	700	S02
+ * 76	 8325	700	S03
+ * 
+ * 80	10525	700	S1
+ * 81	11225	700	S2
+ * 82	11925	700	S3
+ * 83	12625	700	S4
+ * 84	13325	700	S5
+ * 85	14025	700	S6
+ * 86	14725	700	S7
+ * 87	15425	700	S8
+ * 88	16125	700	S9
+ * 89	16825	700	S10
+ * 90	23125	700	S11
+ * 91	23825	700	S12
+ * 92	24525	700	S13
+ * 93	25225	700	S14
+ * 94	25925	700	S15
+ * 95	26625	700	S16
+ * 96	27325	700	S17
+ * 97	28025	700	S18
+ * 98	28725	700	S19
+ * 99	29425	700	S20
+ *
+ *
+ * Channels S21 - S41 are taken from
+ * http://gemma.apple.com:80/dev/technotes/tn/tn1012.html
+ *
+ * 100	30325	800	S21
+ * 101	31125	800	S22
+ * 102	31925	800	S23
+ * 103	32725	800	S24
+ * 104	33525	800	S25
+ * 105	34325	800	S26         
+ * 106	35125	800	S27         
+ * 107	35925	800	S28         
+ * 108	36725	800	S29         
+ * 109	37525	800	S30         
+ * 110	38325	800	S31         
+ * 111	39125	800	S32         
+ * 112	39925	800	S33         
+ * 113	40725	800	S34         
+ * 114	41525	800	S35         
+ * 115	42325	800	S36         
+ * 116	43125	800	S37         
+ * 117	43925	800	S38         
+ * 118	44725	800	S39         
+ * 119	45525	800	S40         
+ * 120	46325	800	S41
+ * 
+ * 121	 3890	000	IFFREQ
+ * 
+ */
+static int weurope[] = {
+       121,     (int)( 38.90 * FREQFACTOR),     0, 
+       100,     (int)(303.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR), 
+        90,     (int)(231.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
+        80,     (int)(105.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),  
+        74,     (int)( 69.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),  
+        21,     (int)(471.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
+        17,     (int)(183.25 * FREQFACTOR),     (int)(9.00 * FREQFACTOR),
+        16,     (int)(175.25 * FREQFACTOR),     (int)(9.00 * FREQFACTOR),
+        15,     (int)(82.25 * FREQFACTOR),      (int)(8.50 * FREQFACTOR),
+        13,     (int)(53.75 * FREQFACTOR),      (int)(8.50 * FREQFACTOR),
+         5,     (int)(175.25 * FREQFACTOR),     (int)(7.00 * FREQFACTOR),
+         2,     (int)(48.25 * FREQFACTOR),      (int)(7.00 * FREQFACTOR),
+	 0
+};
+
+/*
+ * Japanese Broadcast Channels:
+ *
+ *  1:  91.25MHz -  3: 103.25MHz
+ *  4: 171.25MHz -  7: 189.25MHz
+ *  8: 193.25MHz - 12: 217.25MHz  (VHF)
+ * 13: 471.25MHz - 62: 765.25MHz  (UHF)
+ *
+ * IF freq: 45.75 mHz
+ *  OR
+ * IF freq: 58.75 mHz
+ */
+#define OFFSET  6.00
+#define IF_FREQ 45.75
+static int jpnbcst[] = {
+	62,     (int)(IF_FREQ * FREQFACTOR),    0,
+	13,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 8,     (int)(193.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 4,     (int)(171.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 1,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 0
+};
+#undef IF_FREQ
+#undef OFFSET
+
+/*
+ * Japanese Cable Channels:
+ *
+ *  1:  91.25MHz -  3: 103.25MHz
+ *  4: 171.25MHz -  7: 189.25MHz
+ *  8: 193.25MHz - 12: 217.25MHz
+ * 13: 109.25MHz - 21: 157.25MHz
+ * 22: 165.25MHz
+ * 23: 223.25MHz - 63: 463.25MHz
+ *
+ * IF freq: 45.75 mHz
+ */
+#define OFFSET  6.00
+#define IF_FREQ 45.75
+static int jpncable[] = {
+	63,     (int)(IF_FREQ * FREQFACTOR),    0,
+	23,     (int)(223.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	22,     (int)(165.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	13,     (int)(109.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 8,     (int)(193.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 4,     (int)(171.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 1,     (int)( 91.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+	 0
+};
+#undef IF_FREQ
+#undef OFFSET
+
+/*
+ * xUSSR Broadcast Channels:
+ *
+ *  1:  49.75MHz -  2:  59.25MHz
+ *  3:  77.25MHz -  5:  93.25MHz
+ *  6: 175.25MHz - 12: 223.25MHz
+ * 13-20 - not exist
+ * 21: 471.25MHz - 34: 575.25MHz
+ * 35: 583.25MHz - 69: 855.25MHz
+ *
+ * Cable channels
+ *
+ * 70: 111.25MHz - 77: 167.25MHz
+ * 78: 231.25MHz -107: 463.25MHz
+ *
+ * IF freq: 38.90 MHz
+ */
+#define IF_FREQ 38.90
+static int xussr[] = {
+      107,     (int)(IF_FREQ * FREQFACTOR),    0,
+       78,     (int)(231.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR), 
+       70,     (int)(111.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
+       35,     (int)(583.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR), 
+       21,     (int)(471.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),
+        6,     (int)(175.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),  
+        3,     (int)( 77.25 * FREQFACTOR),     (int)(8.00 * FREQFACTOR),  
+        1,     (int)( 49.75 * FREQFACTOR),     (int)(9.50 * FREQFACTOR),
+        0
+};
+#undef IF_FREQ
+
+/*
+ * Australian broadcast channels
+ */
+#define OFFSET	7.00
+#define IF_FREQ 38.90 
+static int australia[] = {
+       83,     (int)(IF_FREQ * FREQFACTOR),    0,
+       28,     (int)(527.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+       10,     (int)(209.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+        6,     (int)(175.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+        4,     (int)( 95.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+        3,     (int)( 86.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+        1,     (int)( 57.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR),
+        0
+};
+#undef OFFSET
+#undef IF_FREQ
+
+/* 
+ * France broadcast channels
+ */
+#define OFFSET 8.00
+#define IF_FREQ 38.90
+static int france[] = {
+        69,     (int)(IF_FREQ * FREQFACTOR),     0,
+        21,     (int)(471.25 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 21 -> 69 */
+         5,     (int)(176.00 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 5 -> 10 */
+         4,     (int)( 63.75 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 4    */
+         3,     (int)( 60.50 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 3    */
+         1,     (int)( 47.75 * FREQFACTOR),     (int)(OFFSET * FREQFACTOR), /* 1  2 */
+         0
+}; 
+#undef OFFSET
+#undef IF_FREQ
+
+static struct {
+        int     *ptr;
+        char    name[BT848_MAX_CHNLSET_NAME_LEN];
+} freqTable[] = {
+        {NULL,          ""},
+        {nabcst,        "nabcst"},
+        {irccable,      "cableirc"},
+        {hrccable,      "cablehrc"},
+        {weurope,       "weurope"},
+        {jpnbcst,       "jpnbcst"},
+        {jpncable,      "jpncable"},
+        {xussr,         "xussr"},
+        {australia,     "australia"},
+        {france,        "france"},
+ 
+};
+
+#define TBL_CHNL	freqTable[ bktr->tuner.chnlset ].ptr[ x ]
+#define TBL_BASE_FREQ	freqTable[ bktr->tuner.chnlset ].ptr[ x + 1 ]
+#define TBL_OFFSET	freqTable[ bktr->tuner.chnlset ].ptr[ x + 2 ]
+static int
+frequency_lookup( bktr_ptr_t bktr, int channel )
+{
+	int	x;
+
+	/* check for "> MAX channel" */
+	x = 0;
+	if ( channel > TBL_CHNL )
+		return( -1 );
+
+	/* search the table for data */
+	for ( x = 3; TBL_CHNL; x += 3 ) {
+		if ( channel >= TBL_CHNL ) {
+			return( TBL_BASE_FREQ +
+				 ((channel - TBL_CHNL) * TBL_OFFSET) );
+		}
+	}
+
+	/* not found, must be below the MIN channel */
+	return( -1 );
+}
+#undef TBL_OFFSET
+#undef TBL_BASE_FREQ
+#undef TBL_CHNL
+
+
+#define TBL_IF	freqTable[ bktr->tuner.chnlset ].ptr[ 1 ]
+
+
+/* Initialise the tuner structures in the bktr_softc */
+/* This is needed as the tuner details are no longer globally declared */
+
+void    select_tuner( bktr_ptr_t bktr, int tuner_type ) {
+	if (tuner_type < Bt848_MAX_TUNER) {
+		bktr->card.tuner = &tuners[ tuner_type ];
+	} else {
+		bktr->card.tuner = NULL;
+	}
+}
+
+/*
+ * Tuner Notes:
+ * Programming the tuner properly is quite complicated.
+ * Here are some notes, based on a FM1246 data sheet for a PAL-I tuner.
+ * The tuner (front end) covers 45.75 Mhz - 855.25 Mhz and an FM band of
+ * 87.5 Mhz to 108.0 Mhz.
+ *
+ * RF and IF.  RF = radio frequencies, it is the transmitted signal.
+ *             IF is the Intermediate Frequency (the offset from the base
+ *             signal where the video, color,  audio and NICAM signals are.
+ *
+ * Eg, Picture at 38.9 Mhz, Colour at 34.47 MHz, sound at 32.9 MHz
+ * NICAM at 32.348 Mhz.
+ * Strangely enough, there is an IF (intermediate frequency) for
+ * FM Radio which is 10.7 Mhz.
+ *
+ * The tuner also works in Bands. Philips bands are
+ * FM radio band 87.50 to 108.00 MHz
+ * Low band 45.75 to 170.00 MHz
+ * Mid band 170.00 to 450.00 MHz
+ * High band 450.00 to 855.25 MHz
+ *
+ *
+ * Now we need to set the PLL on the tuner to the required freuqncy.
+ * It has a programmable divisor.
+ * For TV we want
+ *  N = 16 (freq RF(pc) + freq IF(pc))  pc is picture carrier and RF and IF
+ *  are in MHz.
+
+ * For RADIO we want a different equation.
+ *  freq IF is 10.70 MHz (so the data sheet tells me)
+ * N = (freq RF + freq IF) / step size
+ * The step size must be set to 50 khz (so the data sheet tells me)
+ * (note this is 50 kHz, the other things are in MHz)
+ * so we end up with N = 20x(freq RF + 10.7)
+ *
+ */
+
+#define LOW_BAND 0
+#define MID_BAND 1
+#define HIGH_BAND 2
+#define FM_RADIO_BAND 3
+
+
+/* Check if these are correct for other than Philips PAL */
+#define STATUSBIT_COLD   0x80
+#define STATUSBIT_LOCK   0x40
+#define STATUSBIT_TV     0x20
+#define STATUSBIT_STEREO 0x10 /* valid if FM (aka not TV) */
+#define STATUSBIT_ADC    0x07
+
+/*
+ * set the frequency of the tuner
+ * If 'type' is TV_FREQUENCY, the frequency is freq MHz*16
+ * If 'type' is FM_RADIO_FREQUENCY, the frequency is freq MHz * 100 
+ * (note *16 gives is 4 bits of fraction, eg steps of nnn.0625)
+ *
+ */
+int
+tv_freq( bktr_ptr_t bktr, int frequency, int type )
+{
+	const struct TUNER*	tuner;
+	u_char			addr;
+	u_char			control;
+	u_char			band;
+	int			N;
+	int			band_select = 0;
+#if defined( TEST_TUNER_AFC )
+	int			oldFrequency, afcDelta;
+#endif
+
+	tuner = bktr->card.tuner;
+	if ( tuner == NULL )
+		return( -1 );
+
+	if (type == TV_FREQUENCY) {
+		/*
+		 * select the band based on frequency
+		 * XXX FIXME: get the cross-over points from the tuner struct
+		 */
+		if ( frequency < (160 * FREQFACTOR  ) )
+		    band_select = LOW_BAND;
+		else if ( frequency < (454 * FREQFACTOR ) )
+		    band_select = MID_BAND;
+		else
+		    band_select = HIGH_BAND;
+
+#if defined( TEST_TUNER_AFC )
+		if ( bktr->tuner.afc )
+			frequency -= 4;
+#endif
+		/*
+		 * N = 16 * { fRF(pc) + fIF(pc) }
+		 * or N = 16* fRF(pc) + 16*fIF(pc) }
+		 * where:
+		 *  pc is picture carrier, fRF & fIF are in MHz
+		 *
+		 * fortunatly, frequency is passed in as MHz * 16
+		 * and the TBL_IF frequency is also stored in MHz * 16
+		 */
+		N = frequency + TBL_IF;
+
+		/* set the address of the PLL */
+		addr    = bktr->card.tuner_pllAddr;
+		control = tuner->pllControl[ band_select ];
+		band    = tuner->bandAddrs[ band_select ];
+
+		if(!(band && control))		/* Don't try to set un-	*/
+		  return(-1);			/* supported modes.	*/
+
+		if ( frequency > bktr->tuner.frequency ) {
+			i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
+			i2cWrite( bktr, addr, control, band );
+	        }
+	        else {
+			i2cWrite( bktr, addr, control, band );
+			i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
+       		}
+
+#if defined( TUNER_AFC )
+		if ( bktr->tuner.afc == TRUE ) {
+#if defined( TEST_TUNER_AFC )
+			oldFrequency = frequency;
+#endif
+			if ( (N = do_afc( bktr, addr, N )) < 0 ) {
+			    /* AFC failed, restore requested frequency */
+			    N = frequency + TBL_IF;
+#if defined( TEST_TUNER_AFC )
+			    printf("%s: do_afc: failed to lock\n",
+				   bktr_name(bktr));
+#endif
+			    i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
+			}
+			else
+			    frequency = N - TBL_IF;
+#if defined( TEST_TUNER_AFC )
+ printf("%s: do_afc: returned freq %d (%d %% %d)\n", bktr_name(bktr), frequency, frequency / 16, frequency % 16);
+			    afcDelta = frequency - oldFrequency;
+ printf("%s: changed by: %d clicks (%d mod %d)\n", bktr_name(bktr), afcDelta, afcDelta / 16, afcDelta % 16);
+#endif
+			}
+#endif /* TUNER_AFC */
+
+		bktr->tuner.frequency = frequency;
+	}
+
+	if ( type == FM_RADIO_FREQUENCY ) {
+		band_select = FM_RADIO_BAND;
+
+		/*
+		 * N = { fRF(pc) + fIF(pc) }/step_size
+                 * The step size is 50kHz for FM radio.
+		 * (eg after 102.35MHz comes 102.40 MHz)
+		 * fIF is 10.7 MHz (as detailed in the specs)
+		 *
+		 * frequency is passed in as MHz * 100
+		 *
+		 * So, we have N = (frequency/100 + 10.70)  /(50/1000)
+		 */
+		N = (frequency + 1070)/5;
+
+		/* set the address of the PLL */
+		addr    = bktr->card.tuner_pllAddr;
+		control = tuner->pllControl[ band_select ];
+		band    = tuner->bandAddrs[ band_select ];
+
+		if(!(band && control))		/* Don't try to set un-	*/
+		  return(-1);			/* supported modes.	*/
+	  
+		band |= bktr->tuner.radio_mode; /* tuner.radio_mode is set in
+						 * the ioctls RADIO_SETMODE
+						 * and RADIO_GETMODE */
+
+		i2cWrite( bktr, addr, control, band );
+		i2cWrite( bktr, addr, (N>>8) & 0x7f, N & 0xff );
+
+		bktr->tuner.frequency = (N * 5) - 1070;
+
+
+	}
+ 
+
+	return( 0 );
+}
+
+
+
+#if defined( TUNER_AFC )
+/*
+ * 
+ */
+int
+do_afc( bktr_ptr_t bktr, int addr, int frequency )
+{
+	int step;
+	int status;
+	int origFrequency;
+
+	origFrequency = frequency;
+
+	/* wait for first setting to take effect */
+	tsleep( BKTR_SLEEP, PZERO, "tuning", hz/8 );
+
+	if ( (status = i2cRead( bktr, addr + 1 )) < 0 )
+		return( -1 );
+
+#if defined( TEST_TUNER_AFC )
+ printf( "%s: Original freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
+#endif
+	for ( step = 0; step < AFC_MAX_STEP; ++step ) {
+		if ( (status = i2cRead( bktr, addr + 1 )) < 0 )
+			goto fubar;
+		if ( !(status & 0x40) ) {
+#if defined( TEST_TUNER_AFC )
+ printf( "%s: no lock!\n", bktr_name(bktr) );
+#endif
+			goto fubar;
+		}
+
+		switch( status & AFC_BITS ) {
+		case AFC_FREQ_CENTERED:
+#if defined( TEST_TUNER_AFC )
+ printf( "%s: Centered, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
+#endif
+			return( frequency );
+
+		case AFC_FREQ_MINUS_125:
+		case AFC_FREQ_MINUS_62:
+#if defined( TEST_TUNER_AFC )
+ printf( "%s: Low, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
+#endif
+			--frequency;
+			break;
+
+		case AFC_FREQ_PLUS_62:
+		case AFC_FREQ_PLUS_125:
+#if defined( TEST_TUNER_AFC )
+ printf( "%s: Hi, freq: %d, status: 0x%02x\n", bktr_name(bktr), frequency, status );
+#endif
+			++frequency;
+			break;
+		}
+
+		i2cWrite( bktr, addr,
+			  (frequency>>8) & 0x7f, frequency & 0xff );
+		DELAY( AFC_DELAY );
+	}
+
+ fubar:
+	i2cWrite( bktr, addr,
+		  (origFrequency>>8) & 0x7f, origFrequency & 0xff );
+
+	return( -1 );
+}
+#endif /* TUNER_AFC */
+#undef TBL_IF
+
+
+/*
+ * Get the Tuner status and signal strength
+ */
+int     get_tuner_status( bktr_ptr_t bktr ) {
+	return i2cRead( bktr, bktr->card.tuner_pllAddr + 1 );
+}
+
+/*
+ * set the channel of the tuner
+ */
+int
+tv_channel( bktr_ptr_t bktr, int channel )
+{
+	int frequency;
+
+	/* calculate the frequency according to tuner type */
+	if ( (frequency = frequency_lookup( bktr, channel )) < 0 )
+		return( -1 );
+
+	/* set the new frequency */
+	if ( tv_freq( bktr, frequency, TV_FREQUENCY ) < 0 )
+		return( -1 );
+
+	/* OK to update records */
+	return( (bktr->tuner.channel = channel) );
+}
+
+/*
+ * get channelset name
+ */
+int
+tuner_getchnlset(struct bktr_chnlset *chnlset)
+{
+       if (( chnlset->index < CHNLSET_MIN ) ||
+               ( chnlset->index > CHNLSET_MAX ))
+                       return( EINVAL );
+
+       memcpy(&chnlset->name, &freqTable[chnlset->index].name,
+               BT848_MAX_CHNLSET_NAME_LEN);
+
+       chnlset->max_channel=freqTable[chnlset->index].ptr[0];
+       return( 0 );
+}
diff --git a/sys/dev/pci/bktr/bktr_tuner.h b/sys/dev/pci/bktr/bktr_tuner.h
new file mode 100644
index 00000000000..5ca817d26e7
--- /dev/null
+++ b/sys/dev/pci/bktr/bktr_tuner.h
@@ -0,0 +1,104 @@
+/*	$OpenBSD: bktr_tuner.h,v 1.1 2001/03/28 03:27:10 fgsch Exp $	*/
+/* $FreeBSD: src/sys/dev/bktr/bktr_tuner.h,v 1.1 1999/09/26 22:06:20 roger Exp $ */
+
+/*
+ * This is part of the Driver for Video Capture Cards (Frame grabbers)
+ * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
+ * chipset.
+ * Copyright Roger Hardiman and Amancio Hasty.
+ * 
+ * bktr_tuner : This deals with controlling the tuner fitted to TV cards.
+ *
+ */
+
+/*
+ * 1. Redistributions of source code must retain the
+ * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Amancio Hasty and
+ *      Roger Hardiman
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Definitions for Tuners */
+
+#define NO_TUNER                0
+#define TEMIC_NTSC              1
+#define TEMIC_PAL               2
+#define TEMIC_SECAM             3
+#define PHILIPS_NTSC            4
+#define PHILIPS_PAL             5
+#define PHILIPS_SECAM           6
+#define TEMIC_PALI              7
+#define PHILIPS_PALI            8
+#define PHILIPS_FR1236_NTSC     9    /* These have FM radio support */
+#define PHILIPS_FR1216_PAL      10   /* These have FM radio support */
+#define PHILIPS_FR1236_SECAM    11   /* These have FM radio support */
+#define ALPS_TSCH5              12
+#define ALPS_TSBH1              13
+#define Bt848_MAX_TUNER         14
+
+/* experimental code for Automatic Frequency Control */ 
+#define TUNER_AFC
+
+/*
+ * Fill in the tuner entries in the bktr_softc based on the selected tuner
+ * type (from the list of tuners above)
+ */
+void	select_tuner( bktr_ptr_t bktr, int tuner_type );
+
+
+/*
+ * The Channel Set maps TV channels eg Ch 36, Ch 51, onto frequencies
+ * and is country specific.
+ */
+int	tuner_getchnlset( struct bktr_chnlset *chnlset );
+
+/*
+ * tv_channel sets the tuner to channel 'n' using the current Channel Set
+ * tv_freq sets the tuner to a specific frequency for TV or for FM Radio
+ * get_tuner_status can be used to get the signal strength.
+ */
+#define TV_FREQUENCY       0
+#define FM_RADIO_FREQUENCY 1
+int	tv_channel( bktr_ptr_t bktr, int channel );
+int	tv_freq( bktr_ptr_t bktr, int frequency, int type );
+int	get_tuner_status( bktr_ptr_t bktr );
+
+#if defined( TUNER_AFC )
+int	do_afc( bktr_ptr_t bktr, int addr, int frequency );
+#endif /* TUNER_AFC */
+
+
+/* 
+ * This is for start-up convenience only, NOT mandatory.
+ */
+#if !defined( DEFAULT_CHNLSET )
+#define DEFAULT_CHNLSET CHNLSET_WEUROPE
+#endif
+
+