diff -urN saa7134-0.1.11/Make.config saa7134-0.1.11.monstertv1/Make.config
--- saa7134-0.1.11/Make.config	2002-07-25 16:20:27.000000000 +0900
+++ saa7134-0.1.11.monstertv1/Make.config	2002-10-11 00:45:53.000000000 +0900
@@ -5,8 +5,8 @@
 saa7134-objs    := saa7134-core.o saa7134-i2c.o saa7134-video.o \
 		   saa7134-vbi.o saa7134-tvaudio.o saa7134-oss.o \
 		   saa7134-cards.o saa7134-ts.o
-obj-m		:= tuner.o video-buf.o saa7134.o tda9887.o
+obj-m		:= tuner.o video-buf.o saa7134.o tda9887.o msp34x5.o
 
 tardest		:= $(HOME)/bytesex/saa7134
 
-$(obj-m) : CC := gcc -I../v4l2
+$(obj-m) : CC := gcc-3.2 -I../v4l2
diff -urN saa7134-0.1.11/msp34x5.c saa7134-0.1.11.monstertv1/msp34x5.c
--- saa7134-0.1.11/msp34x5.c	1970-01-01 09:00:00.000000000 +0900
+++ saa7134-0.1.11.monstertv1/msp34x5.c	2002-10-11 00:45:53.000000000 +0900
@@ -0,0 +1,1646 @@
+/*
+ * programming the msp34* sound processor family
+ *
+ * (c) 1997-2001 Gerd Knorr <kraxel@bytesex.org>
+ *
+ * what works and what doesn't:
+ *
+ *  AM-Mono
+ *      Support for Hauppauge cards added (decoding handled by tuner) added by
+ *      Frederic Crozat <fcrozat@mail.dotcom.fr>
+ *
+ *  FM-Mono
+ *      should work. The stereo modes are backward compatible to FM-mono,
+ *      therefore FM-Mono should be allways available.
+ *
+ *  FM-Stereo (B/G, used in germany)
+ *      should work, with autodetect
+ *
+ *  FM-Stereo (satellite)
+ *      should work, no autodetect (i.e. default is mono, but you can
+ *      switch to stereo -- untested)
+ *
+ *  NICAM (B/G, L , used in UK, Scandinavia, Spain and France)
+ *      should work, with autodetect. Support for NICAM was added by
+ *      Pekka Pietikainen <pp@netppl.fi>
+ *
+ *
+ * TODO:
+ *   - better SAT support
+ *
+ *
+ * 980623  Thomas Sailer (sailer@ife.ee.ethz.ch)
+ *         using soundcore instead of OSS
+ *
+ * 020915 branch from 2.4.20pre6 for MSP3445G with SAA7134HL
+ *        K.Ohta <alpha292@bremen.or.jp>
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/timer.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/videodev.h>
+#include <asm/semaphore.h>
+#include <linux/init.h>
+
+#ifdef CONFIG_SMP
+#include <asm/pgtable.h>
+#include <linux/smp_lock.h>
+#endif
+/* kernel_thread */
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+
+#include "audiochip.h"
+#include "msp34x5.h" /* 20020915 K.O */
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = {I2C_CLIENT_END};
+static unsigned short normal_i2c_range[] = {0x40,0x40,I2C_CLIENT_END}; /* 20020915 K.O */
+static unsigned short probe[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short probe_range[2]  = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short ignore[2]       = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short force[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };
+static struct i2c_client_address_data addr_data = {
+	normal_i2c, normal_i2c_range, 
+	probe, probe_range, 
+	ignore, ignore_range, 
+	force
+};
+
+/* insmod parameters */
+static int debug   = 0;    /* debug output */
+static int once    = 0;    /* no continous stereo monitoring */
+static int amsound = 0;    /* hard-wire AM sound at 6.5 Hz (france),
+			      the autoscan seems work well only with FM... */
+static int simple  = -1;   /* use short programming (>= msp3410 only) */
+static int dolby   = 0;
+
+#define DFP_COUNT 0x41
+static const int bl_dfp[] = {
+	0x00, 0x01, 0x02, 0x03,  0x06, 0x08, 0x09, 0x0a,
+	0x0b, 0x0d, 0x0e, 0x10
+};
+
+struct msp3400c {
+	int simple;
+	int nicam;
+	int mode;
+	int norm;
+	int stereo;
+	int nicam_on;
+	int acb;
+	int main, second;	/* sound carrier */
+	int input;
+
+	int muted;
+	int left, right;	/* volume */
+	int bass, treble;
+
+	/* shadow register set */
+	int dfp_regs[DFP_COUNT];
+
+	/* thread */
+	struct task_struct  *thread;
+	wait_queue_head_t    wq;
+
+	struct semaphore    *notify;
+	int                  active,restart,rmmod;
+
+	int                  watch_stereo;
+	struct timer_list    wake_stereo;
+};
+
+#define MSP3400_MAX 4
+static struct i2c_client *msps[MSP3400_MAX];
+
+#define VIDEO_MODE_RADIO 16      /* norm magic for radio mode */
+
+/* ---------------------------------------------------------------------- */
+
+#define dprintk     if (debug) printk
+
+MODULE_PARM(once,"i");
+MODULE_PARM(debug,"i");
+MODULE_PARM(simple,"i");
+MODULE_PARM(amsound,"i");
+MODULE_PARM(dolby,"i");
+
+MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
+MODULE_AUTHOR("Gerd Knorr");
+MODULE_LICENSE("GPL");
+
+/* ---------------------------------------------------------------------- */
+
+#define I2C_MSP3400C       0x80
+#define I2C_MSP3400C_DEM   0x10
+#define I2C_MSP3400C_DFP   0x12
+
+/* ----------------------------------------------------------------------- */
+/* functions for talking to the MSP3400C Sound processor                   */
+
+static int msp3400c_reset(struct i2c_client *client)
+{
+        static char reset_off[3] = { 0x00, 0x80, 0x00 };
+        static char reset_on[3]  = { 0x00, 0x00, 0x00 };
+
+        i2c_master_send(client,reset_off,3);  /* XXX ignore errors here */
+        if (3 != i2c_master_send(client,reset_on, 3)) {
+		printk(KERN_ERR "msp34x5: chip reset failed, penguin on i2c bus?\n");
+                return -1;
+	}
+        return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+/* functions for talking to the MSP3445G Sound processor                   */
+
+
+static int msp3445g_reset(struct i2c_client *client)
+{
+        static char reset_off[3] = { 0x00, 0x80, 0x00 };
+        static char reset_on[3]  = { 0x00, 0x00, 0x00 };
+
+        i2c_master_send(client,reset_off,3);  /* XXX ignore errors here */
+        if (3 != i2c_master_send(client,reset_on, 3)) {
+		printk(KERN_ERR "msp34x5: chip reset failed, penguin on i2c bus?\n");
+                return -1;
+	}
+        return 0;
+}
+
+
+
+static int
+msp3400c_read(struct i2c_client *client, int dev, int addr)
+{
+	int err;
+
+        unsigned char write[3];
+        unsigned char read[2];
+        struct i2c_msg msgs[2] = {
+                { client->addr, 0,        3, write },
+                { client->addr, I2C_M_RD, 2, read  }
+        };
+        write[0] = dev+1;
+        write[1] = addr >> 8;
+        write[2] = addr & 0xff;
+
+	for (err = 0; err < 3;) {
+		if (2 == i2c_transfer(client->adapter,msgs,2))
+			break;
+		err++;
+		printk(KERN_WARNING "msp34xx: I/O error #%d (read 0x%02x/0x%02x)\n",
+		       err, dev, addr);
+		current->state = TASK_INTERRUPTIBLE;
+		schedule_timeout(HZ/10);
+	}
+	if (3 == err) {
+		printk(KERN_WARNING "msp34xx: giving up, reseting chip. Sound will go off, sorry folks :-|\n");
+		msp3445g_reset(client);
+		return -1;
+	}
+        return read[0] << 8 | read[1];
+}
+
+static int
+msp3400c_write(struct i2c_client *client, int dev, int addr, int val)
+{
+	int err;
+        unsigned char buffer[5];
+
+        buffer[0] = dev;
+        buffer[1] = addr >> 8;
+        buffer[2] = addr &  0xff;
+        buffer[3] = val  >> 8;
+        buffer[4] = val  &  0xff;
+
+	for (err = 0; err < 3;) {
+		if (5 == i2c_master_send(client, buffer, 5))
+			break;
+		err++;
+		printk(KERN_WARNING "msp34xx: I/O error #%d (write 0x%02x/0x%02x)\n",
+		       err, dev, addr);
+		current->state = TASK_INTERRUPTIBLE;
+		schedule_timeout(HZ/10);
+	}
+	if (3 == err) {
+		printk(KERN_WARNING "msp34xx: giving up, reseting chip. Sound will go off, sorry folks :-|\n");
+		msp3445g_reset(client);
+		return -1;
+	}
+	return 0;
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* This macro is allowed for *constants* only, gcc must calculate it
+   at compile time.  Remember -- no floats in kernel mode */
+#define MSP_CARRIER(freq) ((int)((float)(freq/18.432)*(1<<24)))
+
+#define MSP_MODE_AM_DETECT   0
+#define MSP_MODE_FM_RADIO    2
+#define MSP_MODE_FM_TERRA    3
+#define MSP_MODE_FM_SAT      4
+#define MSP_MODE_FM_NICAM1   5
+#define MSP_MODE_FM_NICAM2   6
+#define MSP_MODE_AM_NICAM    7
+#define MSP_MODE_BTSC        8
+#define MSP_MODE_EXTERN      9
+#define MSP_MODE_EIAJ_TVFM   10 /* 20020915 K.O */
+
+static struct MSP_INIT_DATA_DEM {
+	int fir1[6];
+	int fir2[6];
+	int cdo1;
+	int cdo2;
+	int ad_cv;
+	int mode_reg;
+	int dfp_src;
+	int dfp_matrix;
+} msp_init_data[] = {
+	/* AM (for carrier detect / msp3400) */
+	{ { 75, 19, 36, 35, 39, 40 }, { 75, 19, 36, 35, 39, 40 },
+	  MSP_CARRIER(5.5), MSP_CARRIER(5.5),
+	  0x00d0, 0x0500,   0x0020, 0x3000},
+
+	/* AM (for carrier detect / msp3410) */
+	{ { -1, -1, -8, 2, 59, 126 }, { -1, -1, -8, 2, 59, 126 },
+	  MSP_CARRIER(5.5), MSP_CARRIER(5.5),
+	  0x00d0, 0x0100,   0x0020, 0x3000},
+
+	/* FM Radio */
+	{ { -8, -8, 4, 6, 78, 107 }, { -8, -8, 4, 6, 78, 107 },
+	  MSP_CARRIER(10.7), MSP_CARRIER(10.7),
+	  0x00d0, 0x0480, 0x0020, 0x3000 },
+
+	/* Terrestial FM-mono + FM-stereo */
+	{ {  3, 18, 27, 48, 66, 72 }, {  3, 18, 27, 48, 66, 72 },
+	  MSP_CARRIER(5.5), MSP_CARRIER(5.5),
+	  0x00d0, 0x0480,   0x0030, 0x3000},
+
+	/* Sat FM-mono */
+	{ {  1,  9, 14, 24, 33, 37 }, {  3, 18, 27, 48, 66, 72 },
+	  MSP_CARRIER(6.5), MSP_CARRIER(6.5),
+	  0x00c6, 0x0480,   0x0000, 0x3000},
+
+	/* NICAM/FM --  B/G (5.5/5.85), D/K (6.5/5.85) */
+	{ { -2, -8, -10, 10, 50, 86 }, {  3, 18, 27, 48, 66, 72 },
+	  MSP_CARRIER(5.5), MSP_CARRIER(5.5),
+	  0x00d0, 0x0040,   0x0120, 0x3000},
+
+	/* NICAM/FM -- I (6.0/6.552) */
+	{ {  2, 4, -6, -4, 40, 94 }, {  3, 18, 27, 48, 66, 72 },
+	  MSP_CARRIER(6.0), MSP_CARRIER(6.0),
+	  0x00d0, 0x0040,   0x0120, 0x3000},
+
+	/* NICAM/AM -- L (6.5/5.85) */
+	{ {  -2, -8, -10, 10, 50, 86 }, {  -4, -12, -9, 23, 79, 126 },
+	  MSP_CARRIER(6.5), MSP_CARRIER(6.5),
+	  0x00c6, 0x0140,   0x0120, 0x7c03},
+       
+        /* EIA-J AUDIO -- TV/FM (4.5) */
+        { { -8, -8, 4, 6, 78, 107 }, { -8, -8, 4, 6, 78, 107 },
+	  MSP_CARRIER(4.5), MSP_CARRIER(4.5),
+	  0x00d0, 0x0038, 0x0020, 0x3000 },
+   
+};
+
+struct CARRIER_DETECT {
+	int   cdo;
+	char *name;
+};
+
+static struct CARRIER_DETECT carrier_detect_main[] = {
+	/* main carrier */
+	{ MSP_CARRIER(4.5),        "4.5   NTSC"                   }, 
+	{ MSP_CARRIER(5.5),        "5.5   PAL B/G"                }, 
+	{ MSP_CARRIER(6.0),        "6.0   PAL I"                  },
+	{ MSP_CARRIER(6.5),        "6.5   PAL D/K + SAT + SECAM"  }
+};
+
+static struct CARRIER_DETECT carrier_detect_55[] = {
+	/* PAL B/G */
+	{ MSP_CARRIER(5.7421875),  "5.742 PAL B/G FM-stereo"     }, 
+	{ MSP_CARRIER(5.85),       "5.85  PAL B/G NICAM"         }
+};
+
+static struct CARRIER_DETECT carrier_detect_65[] = {
+	/* PAL SAT / SECAM */
+	{ MSP_CARRIER(5.85),       "5.85  PAL D/K + SECAM NICAM" },
+	{ MSP_CARRIER(6.2578125),  "6.25  PAL D/K1 FM-stereo" },
+	{ MSP_CARRIER(6.7421875),  "6.74  PAL D/K2 FM-stereo" },
+	{ MSP_CARRIER(7.02),       "7.02  PAL SAT FM-stereo s/b" },
+	{ MSP_CARRIER(7.20),       "7.20  PAL SAT FM-stereo s"   },
+	{ MSP_CARRIER(7.38),       "7.38  PAL SAT FM-stereo b"   },
+};
+
+#define CARRIER_COUNT(x) (sizeof(x)/sizeof(struct CARRIER_DETECT))
+
+/* ----------------------------------------------------------------------- */
+
+#define SCART_MASK    0
+#define SCART_IN1     1
+#define SCART_IN2     2
+#define SCART_IN1_DA  3
+#define SCART_IN2_DA  4
+#define SCART_IN3     5
+#define SCART_IN4     6
+#define SCART_MONO    7
+#define SCART_MUTE    8
+
+static int scarts[3][9] = {
+  /* MASK    IN1     IN2     IN1_DA  IN2_DA  IN3     IN4     MONO    MUTE   */
+  {  0x0320, 0x0000, 0x0200, -1,     -1,     0x0300, 0x0020, 0x0100, 0x0320 },
+  {  0x0c40, 0x0440, 0x0400, 0x0c00, 0x0040, 0x0000, 0x0840, 0x0800, 0x0c40 },
+  {  0x3080, 0x1000, 0x1080, 0x0000, 0x0080, 0x2080, 0x3080, 0x2000, 0x3000 },
+};
+
+static char *scart_names[] = {
+  "mask", "in1", "in2", "in1 da", "in2 da", "in3", "in4", "mono", "mute"
+};
+
+static void
+msp3400c_set_scart(struct i2c_client *client, int in, int out)
+{
+	struct msp3400c *msp = client->data;
+
+	if (-1 == scarts[out][in])
+		return;
+
+	dprintk("msp34xx: scart switch: %s => %d\n",scart_names[in],out);
+	msp->acb &= ~scarts[out][SCART_MASK];
+	msp->acb |=  scarts[out][in];
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0013, msp->acb);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void msp3400c_setcarrier(struct i2c_client *client, int cdo1, int cdo2)
+{
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0093, cdo1 & 0xfff);
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x009b, cdo1 >> 12);
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x00a3, cdo2 & 0xfff);
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x00ab, cdo2 >> 12);
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0056, 0); /*LOAD_REG_1/2*/
+}
+
+static void msp3400c_setvolume(struct i2c_client *client,
+			       int muted, int left, int right)
+{
+	int vol = 0,val = 0,balance = 0;
+
+	if (!muted) {
+		vol     = (left > right) ? left : right;
+		val     = (vol * 0x73 / 65535) << 8;
+	}
+	if (vol > 0) {
+		balance = ((right-left) * 127) / vol;
+	}
+
+	dprintk("msp34xx: setvolume: mute=%s %d:%d  v=0x%02x b=0x%02x\n",
+		muted ? "on" : "off", left, right, val>>8, balance);
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0000, val); /* loudspeaker */
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0006, val); /* headphones  */
+	/* scart - on/off only */
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0007, val ? 0x4000 : 0);
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0001, balance << 8);
+}
+
+static void msp3400c_setbass(struct i2c_client *client, int bass)
+{
+	int val = ((bass-32768) * 0x60 / 65535) << 8;
+
+	dprintk("msp34xx: setbass: %d 0x%02x\n",bass, val>>8);
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0002, val); /* loudspeaker */
+}
+
+static void msp3400c_settreble(struct i2c_client *client, int treble)
+{
+	int val = ((treble-32768) * 0x60 / 65535) << 8;
+
+	dprintk("msp34xx: settreble: %d 0x%02x\n",treble, val>>8);
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x0003, val); /* loudspeaker */
+}
+
+static void msp3400c_setmode(struct i2c_client *client, int type)
+{
+	struct msp3400c *msp = client->data;
+	int i;
+	
+	dprintk("msp3400: setmode: %d\n",type);
+	msp->mode   = type;
+	msp->stereo = VIDEO_SOUND_MONO;
+
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x00bb,          /* ad_cv */
+		       msp_init_data[type].ad_cv);
+    
+	for (i = 5; i >= 0; i--)                                   /* fir 1 */
+		msp3400c_write(client,I2C_MSP3400C_DEM, 0x0001,
+			       msp_init_data[type].fir1[i]);
+    
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005, 0x0004); /* fir 2 */
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005, 0x0040);
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005, 0x0000);
+	for (i = 5; i >= 0; i--)
+		msp3400c_write(client,I2C_MSP3400C_DEM, 0x0005,
+			       msp_init_data[type].fir2[i]);
+    
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0083,     /* MODE_REG */
+		       msp_init_data[type].mode_reg);
+    
+	msp3400c_setcarrier(client, msp_init_data[type].cdo1,
+			    msp_init_data[type].cdo2);
+    
+	msp3400c_write(client,I2C_MSP3400C_DEM, 0x0056, 0); /*LOAD_REG_1/2*/
+
+	if (dolby) {
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,
+			       0x0520); /* I2S1 */
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,
+			       0x0620); /* I2S2 */
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,
+			       msp_init_data[type].dfp_src);
+	} else {
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,
+			       msp_init_data[type].dfp_src);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,
+			       msp_init_data[type].dfp_src);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,
+			       msp_init_data[type].dfp_src);
+	}
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x000a,
+		       msp_init_data[type].dfp_src);
+	msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e,
+		       msp_init_data[type].dfp_matrix);
+
+	if (msp->nicam) {
+		/* nicam prescale */
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0010, 0x5a00); /* was: 0x3000 */
+	}
+}
+
+/* turn on/off nicam + stereo */
+static void msp3400c_setstereo(struct i2c_client *client, int mode)
+{
+	static char *strmode[] = { "0", "mono", "stereo", "3",
+				   "lang1", "5", "6", "7", "lang2" };
+	struct msp3400c *msp = client->data;
+	int nicam=0; /* channel source: FM/AM or nicam */
+	int src=0;
+
+	/* switch demodulator */
+	switch (msp->mode) {
+	case MSP_MODE_FM_TERRA:
+		dprintk("msp3400: FM setstereo: %s\n",strmode[mode]);
+		msp3400c_setcarrier(client,msp->second,msp->main);
+		switch (mode) {
+		case VIDEO_SOUND_STEREO:
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3001);
+			break;
+		case VIDEO_SOUND_MONO:
+		case VIDEO_SOUND_LANG1:
+		case VIDEO_SOUND_LANG2:
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3000);
+			break;
+		}
+		break;
+	case MSP_MODE_FM_SAT:
+		dprintk("msp3400: SAT setstereo: %s\n",strmode[mode]);
+		switch (mode) {
+		case VIDEO_SOUND_MONO:
+			msp3400c_setcarrier(client, MSP_CARRIER(6.5), MSP_CARRIER(6.5));
+			break;
+		case VIDEO_SOUND_STEREO:
+			msp3400c_setcarrier(client, MSP_CARRIER(7.2), MSP_CARRIER(7.02));
+			break;
+		case VIDEO_SOUND_LANG1:
+			msp3400c_setcarrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
+			break;
+		case VIDEO_SOUND_LANG2:
+			msp3400c_setcarrier(client, MSP_CARRIER(7.38), MSP_CARRIER(7.02));
+			break;
+		}
+		break;
+	case MSP_MODE_FM_NICAM1:
+	case MSP_MODE_FM_NICAM2:
+	case MSP_MODE_AM_NICAM:
+		dprintk("msp3400: NICAM setstereo: %s\n",strmode[mode]);
+		msp3400c_setcarrier(client,msp->second,msp->main);
+		if (msp->nicam_on)
+			nicam=0x0100;
+		break;
+	case MSP_MODE_BTSC:
+		dprintk("msp3400: BTSC setstereo: %s\n",strmode[mode]);
+		nicam=0x0300;
+		break;
+	case MSP_MODE_EXTERN:
+		dprintk("msp3400: extern setstereo: %s\n",strmode[mode]);
+		nicam = 0x0200;
+		break;
+	case MSP_MODE_FM_RADIO:
+		dprintk("msp3400: FM-Radio setstereo: %s\n",strmode[mode]);
+		break;
+	case MSP_MODE_EIAJ_TVFM:
+		dprintk("msp3400: EIA-J setstereo: %s\n",strmode[mode]);
+		msp3400c_setcarrier(client,msp->second,msp->main);
+		switch (mode) {
+		case VIDEO_SOUND_STEREO:
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3002);
+			break;
+		case VIDEO_SOUND_MONO:
+		        msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3000);
+			break;
+		case VIDEO_SOUND_LANG1:
+		        msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3003);
+			break;
+		case VIDEO_SOUND_LANG2:
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x000e, 0x3004);
+			break;
+		}
+		break;
+	 default:
+		dprintk("msp3400: mono setstereo\n");
+		return;
+	}
+
+	/* switch audio */
+	switch (mode) {
+	case VIDEO_SOUND_STEREO:
+		src = 0x0020 | nicam;
+#if 0 
+		/* spatial effect */
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0005,0x4000);
+#endif
+		break;
+	case VIDEO_SOUND_MONO:
+		if (msp->mode == MSP_MODE_AM_NICAM) {
+			dprintk("msp3400: switching to AM mono\n");
+			/* AM mono decoding is handled by tuner, not MSP chip */
+			/* SCART switching control register */
+			msp3400c_set_scart(client,SCART_MONO,0);
+			src = 0x0200;
+			break;
+		}
+	case VIDEO_SOUND_LANG1:
+		src = 0x0000 | nicam;
+		break;
+	case VIDEO_SOUND_LANG2:
+		src = 0x0010 | nicam;
+		break;
+	}
+	dprintk("msp3400: setstereo final source/matrix = 0x%x\n", src);
+
+	if (dolby) {
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,0x0520);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,0x0620);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x000a,src);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,src);
+	} else {
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0008,src);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x0009,src);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x000a,src);
+		msp3400c_write(client,I2C_MSP3400C_DFP, 0x000b,src);
+	}
+}
+
+static void
+msp3400c_print_mode(struct msp3400c *msp)
+{
+	if (msp->main == msp->second) {
+		printk("msp3400: mono sound carrier: %d.%03d MHz\n",
+		       msp->main/910000,(msp->main/910)%1000);
+	} else {
+		printk("msp3400: main sound carrier: %d.%03d MHz\n",
+		       msp->main/910000,(msp->main/910)%1000);
+	}
+	if (msp->mode == MSP_MODE_FM_NICAM1 ||
+	    msp->mode == MSP_MODE_FM_NICAM2)
+		printk("msp3400: NICAM/FM carrier   : %d.%03d MHz\n",
+		       msp->second/910000,(msp->second/910)%1000);
+	if (msp->mode == MSP_MODE_AM_NICAM)
+		printk("msp3400: NICAM/AM carrier   : %d.%03d MHz\n",
+		       msp->second/910000,(msp->second/910)%1000);
+	if (msp->mode == MSP_MODE_FM_TERRA &&
+	    msp->main != msp->second) {
+		printk("msp3400: FM-stereo carrier : %d.%03d MHz\n",
+		       msp->second/910000,(msp->second/910)%1000);
+	}
+}
+
+static void
+msp3400c_restore_dfp(struct i2c_client *client)
+{
+	struct msp3400c *msp = client->data;
+	int i;
+
+	for (i = 0; i < DFP_COUNT; i++) {
+		if (-1 == msp->dfp_regs[i])
+			continue;
+		msp3400c_write(client,I2C_MSP3400C_DFP, i, msp->dfp_regs[i]);
+	}
+}
+
+/* ----------------------------------------------------------------------- */
+
+struct REGISTER_DUMP {
+	int   addr;
+	char *name;
+};
+
+struct REGISTER_DUMP d1[] = {
+	{ 0x007e, "autodetect" },
+	{ 0x0023, "C_AD_BITS " },
+	{ 0x0038, "ADD_BITS  " },
+	{ 0x003e, "CIB_BITS  " },
+	{ 0x0057, "ERROR_RATE" },
+};
+
+static int
+autodetect_stereo(struct i2c_client *client)
+{
+	struct msp3400c *msp = client->data;
+	int val;
+	int newstereo = msp->stereo;
+	int newnicam  = msp->nicam_on;
+	int update = 0;
+
+	switch (msp->mode) {
+	case MSP_MODE_FM_TERRA:
+		val = msp3400c_read(client, I2C_MSP3400C_DFP, 0x18);
+		if (val > 32767)
+			val -= 65536;
+		dprintk("msp34xx: stereo detect register: %d\n",val);
+		
+		if (val > 4096) {
+			newstereo = VIDEO_SOUND_STEREO | VIDEO_SOUND_MONO;
+		} else if (val < -4096) {
+			newstereo = VIDEO_SOUND_LANG1 | VIDEO_SOUND_LANG2;
+		} else {
+			newstereo = VIDEO_SOUND_MONO;
+		}
+		newnicam = 0;
+		break;
+	case MSP_MODE_FM_NICAM1:
+	case MSP_MODE_FM_NICAM2:
+	case MSP_MODE_AM_NICAM:
+		val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x23);
+		dprintk("msp34xx: nicam sync=%d, mode=%d\n",val & 1, (val & 0x1e) >> 1);
+
+		if (val & 1) {
+			/* nicam synced */
+			switch ((val & 0x1e) >> 1)  {
+			case 0:
+			case 8:
+				newstereo = VIDEO_SOUND_STEREO;
+				break;
+			case 1:
+			case 9:
+				newstereo = VIDEO_SOUND_MONO
+					| VIDEO_SOUND_LANG1;
+				break;
+			case 2:
+			case 10:
+				newstereo = VIDEO_SOUND_MONO
+					| VIDEO_SOUND_LANG1
+					| VIDEO_SOUND_LANG2;
+				break;
+			default:
+				newstereo = VIDEO_SOUND_MONO;
+				break;
+			}
+			newnicam=1;
+		} else {
+			newnicam = 0;
+			newstereo = VIDEO_SOUND_MONO;
+		}
+		break;
+	case MSP_MODE_BTSC:
+		val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x200);
+		dprintk("msp3410: status=0x%x (pri=%s, sec=%s, %s%s%s)\n",
+			val,
+			(val & 0x0002) ? "no"     : "yes",
+			(val & 0x0004) ? "no"     : "yes",
+			(val & 0x0040) ? "stereo" : "mono",
+			(val & 0x0080) ? ", nicam 2nd mono" : "",
+			(val & 0x0100) ? ", bilingual/SAP"  : "");
+		newstereo = VIDEO_SOUND_MONO;
+		if (val & 0x0040) newstereo |= VIDEO_SOUND_STEREO;
+		if (val & 0x0100) newstereo |= VIDEO_SOUND_LANG1;
+		break;
+	 case MSP_MODE_EIAJ_TVFM:
+		val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x200);
+		dprintk("msp3410: status=0x%x (pri=%s, sec=%s, %s%s%s)\n",
+			val,
+			(val & 0x0002) ? "no"     : "yes",
+			(val & 0x0004) ? "no"     : "yes",
+			(val & 0x0040) ? "stereo" : "mono",
+			(val & 0x0080) ? ",  2nd mono" : "",
+			(val & 0x0100) ? ", bilingual/SAP"  : "");
+		newstereo = VIDEO_SOUND_MONO;
+		if (val & 0x0040) newstereo |= VIDEO_SOUND_STEREO;
+		if (val & 0x0100) newstereo |= VIDEO_SOUND_LANG1;
+		break;	         
+	}
+	if (newstereo != msp->stereo) {
+		update = 1;
+		dprintk("msp34xx: watch: stereo %d => %d\n",
+			msp->stereo,newstereo);
+		msp->stereo   = newstereo;
+	}
+	if (newnicam != msp->nicam_on) {
+		update = 1;
+		dprintk("msp34xx: watch: nicam %d => %d\n",
+			msp->nicam_on,newnicam);
+		msp->nicam_on = newnicam;
+	}
+	return update;
+}
+
+/*
+ * A kernel thread for msp3400 control -- we don't want to block the
+ * in the ioctl while doing the sound carrier & stereo detect
+ */
+
+static void msp3400c_stereo_wake(unsigned long data)
+{
+	struct msp3400c *msp = (struct msp3400c*)data;   /* XXX alpha ??? */
+
+	wake_up_interruptible(&msp->wq);
+}
+
+/* stereo/multilang monitoring */
+static void watch_stereo(struct i2c_client *client)
+{
+	struct msp3400c *msp = client->data;
+
+	if (autodetect_stereo(client)) {
+		if (msp->stereo & VIDEO_SOUND_STEREO)
+			msp3400c_setstereo(client,VIDEO_SOUND_STEREO);
+		else if (msp->stereo & VIDEO_SOUND_LANG1)
+			msp3400c_setstereo(client,VIDEO_SOUND_LANG1);
+		else
+			msp3400c_setstereo(client,VIDEO_SOUND_MONO);
+	}
+	if (once)
+		msp->watch_stereo = 0;
+	if (msp->watch_stereo)
+		mod_timer(&msp->wake_stereo, jiffies+5*HZ);
+}
+
+static int msp3400c_thread(void *data)
+{
+	struct i2c_client *client = data;
+	struct msp3400c *msp = client->data;
+	
+	struct CARRIER_DETECT *cd;
+	int count, max1,max2,val1,val2, val,this;
+	
+#ifdef CONFIG_SMP
+	lock_kernel();
+#endif
+	
+	daemonize();
+	sigfillset(&current->blocked);
+	strcpy(current->comm,"msp3400");
+
+	msp->thread = current;
+
+#ifdef CONFIG_SMP
+	unlock_kernel();
+#endif
+
+	printk("msp3400: daemon started\n");
+	if(msp->notify != NULL)
+		up(msp->notify);
+
+	for (;;) {
+		if (msp->rmmod)
+			goto done;
+		if (debug > 1)
+			printk("msp3400: thread: sleep\n");
+		interruptible_sleep_on(&msp->wq);
+		if (debug > 1)
+			printk("msp3400: thread: wakeup\n");
+		if (msp->rmmod || signal_pending(current))
+			goto done;
+
+		if (VIDEO_MODE_RADIO == msp->norm ||
+		    MSP_MODE_EXTERN  == msp->mode)
+			continue;  /* nothing to do */
+	
+		msp->active = 1;
+
+		if (msp->watch_stereo) {
+			watch_stereo(client);
+			msp->active = 0;
+			continue;
+		}
+
+		/* some time for the tuner to sync */
+		current->state   = TASK_INTERRUPTIBLE;
+		schedule_timeout(HZ/5);
+		if (signal_pending(current))
+			goto done;
+		
+	restart:
+		if (VIDEO_MODE_RADIO == msp->norm ||
+		    MSP_MODE_EXTERN  == msp->mode)
+			continue;  /* nothing to do */
+		msp->restart = 0;
+		msp3400c_setvolume(client, msp->muted, 0, 0);
+		msp3400c_setmode(client, MSP_MODE_AM_DETECT /* +1 */ );
+		val1 = val2 = 0;
+		max1 = max2 = -1;
+		del_timer(&msp->wake_stereo);
+		msp->watch_stereo = 0;
+
+		/* carrier detect pass #1 -- main carrier */
+		cd = carrier_detect_main; count = CARRIER_COUNT(carrier_detect_main);
+
+		if (amsound && (msp->norm == VIDEO_MODE_SECAM)) {
+			/* autodetect doesn't work well with AM ... */
+			max1 = 3;
+			count = 0;
+			dprintk("msp3400: AM sound override\n");
+		}
+
+		for (this = 0; this < count; this++) {
+			msp3400c_setcarrier(client, cd[this].cdo,cd[this].cdo);
+
+			current->state   = TASK_INTERRUPTIBLE;
+			schedule_timeout(HZ/10);
+			if (signal_pending(current))
+				goto done;
+			if (msp->restart)
+				msp->restart = 0;
+
+			val = msp3400c_read(client, I2C_MSP3400C_DFP, 0x1b);
+			if (val > 32767)
+				val -= 65536;
+			if (val1 < val)
+				val1 = val, max1 = this;
+			dprintk("msp3400: carrier1 val: %5d / %s\n", val,cd[this].name);
+		}
+	
+		/* carrier detect pass #2 -- second (stereo) carrier */
+		switch (max1) {
+		case 1: /* 5.5 */
+			cd = carrier_detect_55; count = CARRIER_COUNT(carrier_detect_55);
+			break;
+		case 3: /* 6.5 */
+			cd = carrier_detect_65; count = CARRIER_COUNT(carrier_detect_65);
+			break;
+		case 0: /* 4.5 */
+		        cd = carrier_detect_main; count = CARRIER_COUNT(carrier_detect_main);
+		        break;
+		case 2: /* 6.0 */
+		default:
+			cd = NULL; count = 0;
+			break;
+		}
+		
+		if (amsound && (msp->norm == VIDEO_MODE_SECAM)) {
+			/* autodetect doesn't work well with AM ... */
+			cd = NULL; count = 0; max2 = 0;
+		}
+		for (this = 0; this < count; this++) {
+			msp3400c_setcarrier(client, cd[this].cdo,cd[this].cdo);
+
+			current->state   = TASK_INTERRUPTIBLE;
+			schedule_timeout(HZ/10);
+			if (signal_pending(current))
+				goto done;
+			if (msp->restart)
+				goto restart;
+
+			val = msp3400c_read(client, I2C_MSP3400C_DFP, 0x1b);
+			if (val > 32767)
+				val -= 65536;
+			if (val2 < val)
+				val2 = val, max2 = this;
+			dprintk("msp3400: carrier2 val: %5d / %s\n", val,cd[this].name);
+		}
+
+		/* programm the msp3400 according to the results */
+		msp->main   = carrier_detect_main[max1].cdo;
+		switch (max1) {
+		case 1: /* 5.5 */
+			if (max2 == 0) {
+				/* B/G FM-stereo */
+				msp->second = carrier_detect_55[max2].cdo;
+				msp3400c_setmode(client, MSP_MODE_FM_TERRA);
+				msp->nicam_on = 0;
+				msp3400c_setstereo(client, VIDEO_SOUND_MONO);
+				msp->watch_stereo = 1;
+			} else if (max2 == 1 && msp->nicam) {
+				/* B/G NICAM */
+				msp->second = carrier_detect_55[max2].cdo;
+				msp3400c_setmode(client, MSP_MODE_FM_NICAM1);
+				msp->nicam_on = 1;
+				msp3400c_setcarrier(client, msp->second, msp->main);
+				msp->watch_stereo = 1;
+			} else {
+				goto no_second;
+			}
+			break;
+		case 2: /* 6.0 */
+			/* PAL I NICAM */
+			msp->second = MSP_CARRIER(6.552);
+			msp3400c_setmode(client, MSP_MODE_FM_NICAM2);
+			msp->nicam_on = 1;
+			msp3400c_setcarrier(client, msp->second, msp->main);
+			msp->watch_stereo = 1;
+			break;
+		case 3: /* 6.5 */
+			if (max2 == 1 || max2 == 2) {
+				/* D/K FM-stereo */
+				msp->second = carrier_detect_65[max2].cdo;
+				msp3400c_setmode(client, MSP_MODE_FM_TERRA);
+				msp->nicam_on = 0;
+				msp3400c_setstereo(client, VIDEO_SOUND_MONO);
+				msp->watch_stereo = 1;
+			} else if (max2 == 0 &&
+				   msp->norm == VIDEO_MODE_SECAM) {
+				/* L NICAM or AM-mono */
+				msp->second = carrier_detect_65[max2].cdo;
+				msp3400c_setmode(client, MSP_MODE_AM_NICAM);
+				msp->nicam_on = 0;
+				msp3400c_setstereo(client, VIDEO_SOUND_MONO);
+				msp3400c_setcarrier(client, msp->second, msp->main);
+				/* volume prescale for SCART (AM mono input) */
+				msp3400c_write(client,I2C_MSP3400C_DFP, 0x000d, 0x1900);
+				msp->watch_stereo = 1;
+			} else if (max2 == 0 && msp->nicam) {
+				/* D/K NICAM */
+				msp->second = carrier_detect_65[max2].cdo;
+				msp3400c_setmode(client, MSP_MODE_FM_NICAM1);
+				msp->nicam_on = 1;
+				msp3400c_setcarrier(client, msp->second, msp->main);
+				msp->watch_stereo = 1;
+			} else {
+				goto no_second;
+			}
+			break;
+		case 0: /* 4.5 */
+		        /* Example: EIA-J TV/FM ONLY. */
+		   	msp->second = MSP_CARRIER(4.5);
+			msp3400c_setmode(client, MSP_MODE_EIAJ_TVFM);
+			msp->nicam_on = 1;
+			msp3400c_setcarrier(client, msp->second, msp->main);
+			msp->watch_stereo = 1;
+		        break;
+		default:
+		no_second:
+			msp->second = carrier_detect_main[max1].cdo;
+			msp3400c_setmode(client, MSP_MODE_FM_TERRA);
+			msp->nicam_on = 0;
+			msp3400c_setcarrier(client, msp->second, msp->main);
+			msp->stereo = VIDEO_SOUND_MONO;
+			msp3400c_setstereo(client, VIDEO_SOUND_MONO);
+			break;
+		}
+
+		/* unmute + restore dfp registers */
+		msp3400c_setvolume(client, msp->muted, msp->left, msp->right);
+		msp3400c_restore_dfp(client);
+
+		if (msp->watch_stereo)
+			mod_timer(&msp->wake_stereo, jiffies+5*HZ);
+
+		if (debug)
+			msp3400c_print_mode(msp);
+		
+		msp->active = 0;
+	}
+
+done:
+	dprintk("msp3400: thread: exit\n");
+	msp->active = 0;
+	msp->thread = NULL;
+
+	if(msp->notify != NULL)
+		up(msp->notify);
+	return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+/* this one uses the automatic sound standard detection of newer           */
+/* msp34xx chip versions                                                   */
+
+static struct MODES {
+	int retval;
+	int main, second;
+	char *name;
+} modelist[] = {
+	{ 0x0000, 0, 0, "ERROR" },
+	{ 0x0001, 0, 0, "autodetect start" },
+	{ 0x0002, MSP_CARRIER(4.5), MSP_CARRIER(4.72), "4.5/4.72  M Dual FM-Stereo" },
+	{ 0x0003, MSP_CARRIER(5.5), MSP_CARRIER(5.7421875), "5.5/5.74  B/G Dual FM-Stereo" },
+	{ 0x0004, MSP_CARRIER(6.5), MSP_CARRIER(6.2578125), "6.5/6.25  D/K1 Dual FM-Stereo" },
+	{ 0x0005, MSP_CARRIER(6.5), MSP_CARRIER(6.7421875), "6.5/6.74  D/K2 Dual FM-Stereo" },
+	{ 0x0006, MSP_CARRIER(6.5), MSP_CARRIER(6.5), "6.5  D/K FM-Mono (HDEV3)" },
+	{ 0x0008, MSP_CARRIER(5.5), MSP_CARRIER(5.85), "5.5/5.85  B/G NICAM FM" },
+	{ 0x0009, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  L NICAM AM" },
+	{ 0x000a, MSP_CARRIER(6.0), MSP_CARRIER(6.55), "6.0/6.55  I NICAM FM" },
+	{ 0x000b, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM" },
+	{ 0x000c, MSP_CARRIER(6.5), MSP_CARRIER(5.85), "6.5/5.85  D/K NICAM FM (HDEV2)" },
+	{ 0x0020, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M BTSC-Stereo" },
+	{ 0x0021, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M BTSC-Mono + SAP" },
+	{ 0x0030, MSP_CARRIER(4.5), MSP_CARRIER(4.5), "4.5  M EIA-J Japan Stereo" },
+	{ 0x0040, MSP_CARRIER(10.7), MSP_CARRIER(10.7), "10.7  FM-Stereo Radio" },
+	{ 0x0050, MSP_CARRIER(6.5), MSP_CARRIER(6.5), "6.5  SAT-Mono" },
+	{ 0x0051, MSP_CARRIER(7.02), MSP_CARRIER(7.20), "7.02/7.20  SAT-Stereo" },
+	{ 0x0060, MSP_CARRIER(7.2), MSP_CARRIER(7.2), "7.2  SAT ADR" },
+	{     -1, 0, 0, NULL }, /* EOF */
+};
+ 
+static int msp3410d_thread(void *data)
+{
+	struct i2c_client *client = data;
+	struct msp3400c *msp = client->data;
+	int mode,val,i,std;
+    
+#ifdef CONFIG_SMP
+	lock_kernel();
+#endif
+    
+	daemonize();
+	sigfillset(&current->blocked);
+	strcpy(current->comm,"msp3410 [auto]");
+
+	msp->thread = current;
+
+#ifdef CONFIG_SMP
+	unlock_kernel();
+#endif
+
+	printk("msp34x5: daemon started\n");
+	if(msp->notify != NULL)
+		up(msp->notify);
+		
+	for (;;) {
+		if (msp->rmmod)
+			goto done;
+		if (debug > 1)
+			printk("msp3410: thread: sleep\n");
+		interruptible_sleep_on(&msp->wq);
+		if (debug > 1)
+			printk("msp3410: thread: wakeup\n");
+		if (msp->rmmod || signal_pending(current))
+			goto done;
+
+		if (msp->mode == MSP_MODE_EXTERN)
+			continue;
+		
+		msp->active = 1;
+
+		if (msp->watch_stereo) {
+			watch_stereo(client);
+			msp->active = 0;
+			continue;
+		}
+	
+		/* some time for the tuner to sync */
+		current->state   = TASK_INTERRUPTIBLE;
+		schedule_timeout(HZ/5);
+		if (signal_pending(current))
+			goto done;
+
+	restart:
+		if (msp->mode == MSP_MODE_EXTERN)
+			continue;
+		msp->restart = 0;
+		del_timer(&msp->wake_stereo);
+		msp->watch_stereo = 0;
+
+		/* put into sane state (and mute) */
+		msp3400c_reset(client);
+
+		/* start autodetect */
+		switch (msp->norm) {
+		case VIDEO_MODE_PAL:
+			mode = 0x1003;
+			std  = 1;
+			break;
+		case VIDEO_MODE_NTSC:  /* EIA-J */
+			mode = 0x2003;
+			std  = 0x0030;
+			break;
+		case VIDEO_MODE_SECAM: 
+			mode = 0x0003;
+			std  = 1;
+			break;
+		case VIDEO_MODE_RADIO: 
+			mode = 0x0003;
+			std  = 0x0040;
+			break;
+		default:
+			mode = 0x0003;
+			std  = 1;
+			break;
+		}
+		msp3400c_write(client, I2C_MSP3400C_DEM, 0x30, mode);
+		msp3400c_write(client, I2C_MSP3400C_DEM, 0x20, std);
+
+		if (debug) {
+			int i;
+			for (i = 0; modelist[i].name != NULL; i++)
+				if (modelist[i].retval == std)
+					break;
+			printk("msp3410: setting mode: %s (0x%04x)\n",
+			       modelist[i].name ? modelist[i].name : "unknown",std);
+		}
+
+		if (std != 1) {
+			/* programmed some specific mode */
+			val = std;
+		} else {
+			/* triggered autodetect */
+			for (;;) {
+				current->state   = TASK_INTERRUPTIBLE;
+				schedule_timeout(HZ/10);
+				if (signal_pending(current))
+					goto done;
+				if (msp->restart)
+					goto restart;
+
+				/* check results */
+				val = msp3400c_read(client, I2C_MSP3400C_DEM, 0x7e);
+				if (val < 0x07ff)
+					break;
+				dprintk("msp3410: detection still in progress\n");
+			}
+		}
+		for (i = 0; modelist[i].name != NULL; i++)
+			if (modelist[i].retval == val)
+				break;
+		dprintk("msp3410: current mode: %s (0x%04x)\n",
+			modelist[i].name ? modelist[i].name : "unknown",
+			val);
+		msp->main   = modelist[i].main;
+		msp->second = modelist[i].second;
+
+		if (amsound && (msp->norm == VIDEO_MODE_SECAM) && (val != 0x0009)) {
+			/* autodetection has failed, let backup */
+			dprintk("msp3410: autodetection failed, switching to backup mode: %s (0x%04x)\n",
+				modelist[8].name ? modelist[8].name : "unknown",val);
+			val = 0x0009;
+			msp3400c_write(client, I2C_MSP3400C_DEM, 0x20, val);
+		}
+
+		/* set various prescales */
+		msp3400c_write(client, I2C_MSP3400C_DFP, 0x0d, 0x1900); /* scart */
+		msp3400c_write(client, I2C_MSP3400C_DFP, 0x0e, 0x2403); /* FM */
+		msp3400c_write(client, I2C_MSP3400C_DFP, 0x10, 0x5a00); /* nicam */
+
+		/* set stereo */
+		switch (val) {
+		case 0x0008: /* B/G NICAM */
+		case 0x000a: /* I NICAM */
+			if (val == 0x0008)
+				msp->mode = MSP_MODE_FM_NICAM1;
+			else
+				msp->mode = MSP_MODE_FM_NICAM2;
+			/* just turn on stereo */
+			msp->stereo = VIDEO_SOUND_STEREO;
+			msp->nicam_on = 1;
+			msp->watch_stereo = 1;
+			msp3400c_setstereo(client,VIDEO_SOUND_STEREO);
+			break;
+		case 0x0009:			
+			msp->mode = MSP_MODE_AM_NICAM;
+			msp->stereo = VIDEO_SOUND_MONO;
+			msp->nicam_on = 1;
+			msp3400c_setstereo(client,VIDEO_SOUND_MONO);
+			msp->watch_stereo = 1;
+			break;
+		case 0x0020: /* BTSC */
+			/* just turn on stereo */
+			msp->mode   = MSP_MODE_BTSC;
+			msp->stereo = VIDEO_SOUND_STEREO;
+			msp->nicam_on = 0;
+			msp->watch_stereo = 1;
+			msp3400c_setstereo(client,VIDEO_SOUND_STEREO);
+			break;
+		case 0x0040: /* FM radio */
+			msp->mode   = MSP_MODE_FM_RADIO;
+			msp->stereo = VIDEO_SOUND_STEREO;
+			msp->nicam_on = 0;
+			msp->watch_stereo = 0;
+			/* scart routing */
+			msp3400c_set_scart(client,SCART_IN2,0);
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x08, 0x0220);
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x09, 0x0220);
+			msp3400c_write(client,I2C_MSP3400C_DFP, 0x0b, 0x0220);
+			break;
+		case 0x0003:
+			msp->mode   = MSP_MODE_FM_TERRA;
+			msp->stereo = VIDEO_SOUND_MONO;
+			msp->nicam_on = 0;
+			msp->watch_stereo = 1;
+			break;
+		}
+		
+		/* unmute + restore dfp registers */
+		msp3400c_setbass(client, msp->bass);
+		msp3400c_settreble(client, msp->treble);
+		msp3400c_setvolume(client, msp->muted, msp->left, msp->right);
+		msp3400c_restore_dfp(client);
+
+		if (msp->watch_stereo)
+			mod_timer(&msp->wake_stereo, jiffies+HZ);
+
+		msp->active = 0;
+	}
+
+done:
+	dprintk("msp3410: thread: exit\n");
+	msp->active = 0;
+	msp->thread = NULL;
+
+	if(msp->notify != NULL)
+		up(msp->notify);
+	return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+static int msp_attach(struct i2c_adapter *adap, int addr,
+		      unsigned short flags, int kind);
+static int msp_detach(struct i2c_client *client);
+static int msp_probe(struct i2c_adapter *adap);
+static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg);
+
+static struct i2c_driver driver = {
+        name:           "i2c msp34x5 driver",
+        id:             I2C_DRIVERID_MSP3400,
+        flags:          I2C_DF_NOTIFY,
+        attach_adapter: msp_probe,
+        detach_client:  msp_detach,
+        command:        msp_command,
+};
+
+static struct i2c_client client_template = 
+{
+	name:   "(unset)",
+	flags:  I2C_CLIENT_ALLOW_USE,
+        driver: &driver,
+};
+
+static int msp_attach(struct i2c_adapter *adap, int addr,
+		      unsigned short flags, int kind)
+{
+	DECLARE_MUTEX_LOCKED(sem);
+	struct msp3400c *msp;
+        struct i2c_client *c;
+	int              rev1,rev2,i;
+
+        client_template.adapter = adap;
+        client_template.addr = addr;
+
+        if (-1 == msp3400c_reset(&client_template)) {
+                dprintk("msp3400: no chip found\n");
+                return -1;
+        }
+	
+        if (NULL == (c = kmalloc(sizeof(struct i2c_client),GFP_KERNEL)))
+                return -ENOMEM;
+        memcpy(c,&client_template,sizeof(struct i2c_client));
+	if (NULL == (msp = kmalloc(sizeof(struct msp3400c),GFP_KERNEL))) {
+		kfree(c);
+		return -ENOMEM;
+	}
+	
+	memset(msp,0,sizeof(struct msp3400c));
+	msp->left   = 65535;
+	msp->right  = 65535;
+	msp->bass   = 32768;
+	msp->treble = 32768;
+	msp->input  = -1;
+	for (i = 0; i < DFP_COUNT; i++)
+		msp->dfp_regs[i] = -1;
+
+	c->data = msp;
+	init_waitqueue_head(&msp->wq);
+
+	if (-1 == msp3400c_reset(c)) {
+		kfree(msp);
+		kfree(c);
+		dprintk("msp3400: no chip found\n");
+		return -1;
+	}
+    
+	rev1 = msp3400c_read(c, I2C_MSP3400C_DFP, 0x1e);
+	if (-1 != rev1)
+		rev2 = msp3400c_read(c, I2C_MSP3400C_DFP, 0x1f);
+	if ((-1 == rev1) || (0 == rev1 && 0 == rev2)) {
+		kfree(msp);
+		kfree(c);
+		printk("msp3400: error while reading chip version\n");
+		return -1;
+	}
+
+#if 0
+	/* this will turn on a 1kHz beep - might be useful for debugging... */
+	msp3400c_write(c,I2C_MSP3400C_DFP, 0x0014, 0x1040);
+#endif
+
+	sprintf(c->name,"MSP34%02d%c-%c%d",
+		(rev2>>8)&0xff, (rev1&0xff)+'@', ((rev1>>8)&0xff)+'@', rev2&0x1f);
+	msp->nicam = (((rev2>>8)&0xff) != 00) ? 1 : 0;
+
+	if (simple == -1) {
+		/* default mode */
+		/* msp->simple = (((rev2>>8)&0xff) == 0) ? 0 : 1; */
+		msp->simple = ((rev1&0xff)+'@' > 'C');
+	} else {
+		/* use insmod option */
+		msp->simple = simple;
+	}
+
+	/* timer for stereo checking */
+	msp->wake_stereo.function = msp3400c_stereo_wake;
+	msp->wake_stereo.data     = (unsigned long)msp;
+
+	/* hello world :-) */
+	printk(KERN_INFO "msp34xx: init: chip=%s",c->name);
+	if (msp->nicam)
+		printk(", has NICAM support");
+	printk("\n");
+
+	/* startup control thread */
+	MOD_INC_USE_COUNT;
+	msp->notify = &sem;
+	kernel_thread(msp->simple ? msp3410d_thread : msp3400c_thread,
+		      (void *)c, 0);
+	down(&sem);
+	msp->notify = NULL;
+	wake_up_interruptible(&msp->wq);
+
+	/* update our own array */
+	for (i = 0; i < MSP3400_MAX; i++) {
+		if (NULL == msps[i]) {
+			msps[i] = c;
+			break;
+		}
+	}
+	
+	/* done */
+        i2c_attach_client(c);
+	return 0;
+}
+
+static int msp_detach(struct i2c_client *client)
+{
+	DECLARE_MUTEX_LOCKED(sem);
+	struct msp3400c *msp  = (struct msp3400c*)client->data;
+	int i;
+	
+	/* shutdown control thread */
+	del_timer(&msp->wake_stereo);
+	if (msp->thread) 
+	{
+		msp->notify = &sem;
+		msp->rmmod = 1;
+		wake_up_interruptible(&msp->wq);
+		down(&sem);
+		msp->notify = NULL;
+	}
+    	msp3400c_reset(client);
+
+        /* update our own array */
+	for (i = 0; i < MSP3400_MAX; i++) {
+		if (client == msps[i]) {
+			msps[i] = NULL;
+			break;
+		}
+	}
+
+	i2c_detach_client(client);
+	kfree(msp);
+	kfree(client);
+	MOD_DEC_USE_COUNT;
+	return 0;
+}
+
+static int msp_probe(struct i2c_adapter *adap)
+{
+	//if (adap->id == (I2C_ALGO_BIT | I2C_HW_B_BT848))
+		return i2c_probe(adap, &addr_data, msp_attach);
+	return 0;
+}
+
+static void msp_wake_thread(struct i2c_client *client)
+{
+	struct msp3400c *msp  = (struct msp3400c*)client->data;
+
+	msp3400c_setvolume(client,msp->muted,0,0);
+	msp->watch_stereo=0;
+	del_timer(&msp->wake_stereo);
+	if (msp->active)
+		msp->restart = 1;
+	wake_up_interruptible(&msp->wq);
+}
+
+static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg)
+{
+	struct msp3400c *msp  = (struct msp3400c*)client->data;
+        __u16           *sarg = arg;
+#if 0
+	int             *iarg = (int*)arg;
+#endif
+
+	switch (cmd) {
+
+	case AUDC_SET_INPUT:
+		/* scart switching
+		     - IN1 is often used for external input
+		     - Hauppauge uses IN2 for the radio */
+		dprintk(KERN_DEBUG "msp34xx: AUDC_SET_INPUT(%d)\n",*sarg);
+		if (*sarg == msp->input)
+			break;
+		msp->input = *sarg;
+		switch (*sarg) {
+		case AUDIO_RADIO:
+			msp->mode   = MSP_MODE_FM_RADIO;
+			msp->stereo = VIDEO_SOUND_STEREO;
+			msp3400c_set_scart(client,SCART_IN2,0);
+			msp3400c_write(client,I2C_MSP3400C_DFP,0x000d,0x1900);
+			msp3400c_setstereo(client,msp->stereo);
+			break;
+		case AUDIO_EXTERN:
+			msp->mode   = MSP_MODE_EXTERN;
+			msp->stereo = VIDEO_SOUND_STEREO;
+			msp3400c_set_scart(client,SCART_IN1,0);
+			msp3400c_write(client,I2C_MSP3400C_DFP,0x000d,0x1900);
+			msp3400c_setstereo(client,msp->stereo);
+			break;
+		case AUDIO_TUNER:
+			msp->mode   = -1;
+			msp_wake_thread(client);
+			break;
+		default:
+			if (*sarg & AUDIO_MUTE)
+				msp3400c_set_scart(client,SCART_MUTE,0);
+			break;
+		}
+		if (msp->active)
+			msp->restart = 1;
+		break;
+
+	case AUDC_SET_RADIO:
+		dprintk(KERN_DEBUG "msp34xx: AUDC_SET_RADIO\n");
+		msp->norm = VIDEO_MODE_RADIO;
+		msp->watch_stereo=0;
+		del_timer(&msp->wake_stereo);
+		dprintk("msp34xx: switching to radio mode\n");
+		if (msp->simple) {
+			/* the thread will do for us */
+			msp_wake_thread(client);
+		} else {
+			/* set msp3400 to FM radio mode */
+			msp3400c_setmode(client,MSP_MODE_FM_RADIO);
+			msp3400c_setcarrier(client, MSP_CARRIER(10.7),MSP_CARRIER(10.7));
+			msp3400c_setvolume(client,msp->muted,msp->left,msp->right);			
+		}
+		if (msp->active)
+			msp->restart = 1;
+		break;
+
+#if 1
+	/* work-in-progress:  hook to control the DFP registers */
+	case MSP_SET_DFPREG:
+	{
+		struct msp_dfpreg *r = arg;
+		int i;
+
+		if (r->reg < 0 || r->reg >= DFP_COUNT)
+			return -EINVAL;
+		for (i = 0; i < sizeof(bl_dfp)/sizeof(int); i++)
+			if (r->reg == bl_dfp[i])
+				return -EINVAL;
+		msp->dfp_regs[r->reg] = r->value;
+		msp3400c_write(client,I2C_MSP3400C_DFP,r->reg,r->value);
+		return 0;
+	}
+	case MSP_GET_DFPREG:
+	{
+		struct msp_dfpreg *r = arg;
+
+		if (r->reg < 0 || r->reg >= DFP_COUNT)
+			return -EINVAL;
+		r->value = msp3400c_read(client,I2C_MSP3400C_DFP,r->reg);
+		return 0;
+	}
+#endif
+
+	/* --- v4l ioctls --- */
+	/* take care: bttv does userspace copying, we'll get a
+	   kernel pointer here... */
+	case VIDIOCGAUDIO:
+	{
+		struct video_audio *va = arg;
+
+		dprintk(KERN_DEBUG "msp34xx: VIDIOCGAUDIO\n");
+		va->flags |= VIDEO_AUDIO_VOLUME |
+			VIDEO_AUDIO_BASS |
+			VIDEO_AUDIO_TREBLE |
+			VIDEO_AUDIO_MUTABLE;
+		if (msp->muted)
+			va->flags |= VIDEO_AUDIO_MUTE;
+		va->volume=MAX(msp->left,msp->right);
+		va->balance=(32768*MIN(msp->left,msp->right))/
+			(va->volume ? va->volume : 1);
+		va->balance=(msp->left<msp->right)?
+			(65535-va->balance) : va->balance;
+		if (0 == va->volume)
+			va->balance = 32768;
+		va->bass = msp->bass;
+		va->treble = msp->treble;
+
+		if (msp->norm != VIDEO_MODE_RADIO) {
+			autodetect_stereo(client);
+			va->mode = msp->stereo;
+		}
+		break;
+	}
+	case VIDIOCSAUDIO:
+	{
+		struct video_audio *va = arg;
+
+		dprintk(KERN_DEBUG "msp34xx: VIDIOCSAUDIO\n");
+		msp->muted = (va->flags & VIDEO_AUDIO_MUTE);
+		msp->left = (MIN(65536 - va->balance,32768) *
+			     va->volume) / 32768;
+		msp->right = (MIN(va->balance,32768) *
+			      va->volume) / 32768;
+		msp->bass = va->bass;
+		msp->treble = va->treble;
+		msp3400c_setvolume(client,msp->muted,msp->left,msp->right);
+		msp3400c_setbass(client,msp->bass);
+		msp3400c_settreble(client,msp->treble);
+
+		if (va->mode != 0) {
+			msp->watch_stereo=0;
+			del_timer(&msp->wake_stereo);
+			msp->stereo = va->mode;
+			msp3400c_setstereo(client,va->mode);
+		}
+		break;
+	}
+	case VIDIOCSCHAN:
+	{
+		struct video_channel *vc = arg;
+		
+		dprintk(KERN_DEBUG "msp34xx: VIDIOCSCHAN\n");
+		dprintk("msp34xx: switching to TV mode\n");
+		msp->norm = vc->norm;
+		break;
+	}
+	case VIDIOCSFREQ:
+	{
+		/* new channel -- kick audio carrier scan */
+		dprintk(KERN_DEBUG "msp34xx: VIDIOCSFREQ\n");
+		msp_wake_thread(client);
+		break;
+	}
+
+	default:
+		/* nothing */
+		break;
+	}
+	return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+static int msp3400_init_module(void)
+{
+	i2c_add_driver(&driver);
+	return 0;
+}
+
+static void msp3400_cleanup_module(void)
+{
+	i2c_del_driver(&driver);
+}
+
+module_init(msp3400_init_module);
+module_exit(msp3400_cleanup_module);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff -urN saa7134-0.1.11/msp34x5.h saa7134-0.1.11.monstertv1/msp34x5.h
--- saa7134-0.1.11/msp34x5.h	1970-01-01 09:00:00.000000000 +0900
+++ saa7134-0.1.11.monstertv1/msp34x5.h	2002-10-11 00:45:53.000000000 +0900
@@ -0,0 +1,19 @@
+/*
+ * Header for MICRONAS MSP34x5
+ * Modify FROM msp3400 driver @ v2.4.20pre6 
+ * 2002-09-15 K.Ohta
+ */
+#ifndef MSP34x5_H
+#define MSP34x5_H
+
+/* ---------------------------------------------------------------------- */
+
+struct msp_dfpreg {
+    int reg;
+    int value;
+};
+
+#define MSP_SET_DFPREG     _IOW('m',15,struct msp_dfpreg)
+#define MSP_GET_DFPREG     _IOW('m',16,struct msp_dfpreg)
+
+#endif /* MSP34x5_H */
diff -urN saa7134-0.1.11/saa7134-cards.c saa7134-0.1.11.monstertv1/saa7134-cards.c
--- saa7134-0.1.11/saa7134-cards.c	2002-08-22 18:23:06.000000000 +0900
+++ saa7134-0.1.11.monstertv1/saa7134-cards.c	2002-10-11 00:45:53.000000000 +0900
@@ -160,11 +160,12 @@
                /* "K.Ohta" <alpha292@bremen.or.jp> */
                name:           "SKNet Monster TV",
                audio_clock:    0x00187de7,
-               tuner_type:     TUNER_PHILIPS_NTSC_M,
+               tuner_type:     TUNER_PHILIPS_FM1236_MK3,
+	       need_msp34x5: 1,
                inputs: {{
                        name: name_tv,
                        vmux: 1,
-                       amux: TV,
+                       amux: LINE2,
                        tv:   1,
                },{
                        name: name_comp1,
diff -urN saa7134-0.1.11/saa7134-core.c saa7134-0.1.11.monstertv1/saa7134-core.c
--- saa7134-0.1.11/saa7134-core.c	2002-08-07 21:22:12.000000000 +0900
+++ saa7134-0.1.11.monstertv1/saa7134-core.c	2002-10-11 00:45:53.000000000 +0900
@@ -27,6 +27,7 @@
 #include <linux/kmod.h>
 #include <linux/sound.h>
 #include <linux/interrupt.h>
+#include <linux/delay.h>
 
 #include "saa7134-reg.h"
 #include "saa7134.h"
@@ -627,6 +628,33 @@
 	}
 }
 
+/*
+ * reset/enable the MSP on some Hauppauge cards
+ * Thanks to Ky‹šƒ•žMälkki (kmalkki@cc.hut.fi)!
+ *
+ * Hauppauge:  pin  5
+ * Voodoo:     pin 20
+ */
+static void __devinit boot_msp34xx(struct saa7134_dev *dev,int pin)
+{
+	int mask = (1 << pin);
+#if 0
+        btaor(mask, ~mask, BT848_GPIO_OUT_EN);
+        btaor(0, ~mask, BT848_GPIO_DATA);
+        udelay(2500);
+        btaor(mask, ~mask, BT848_GPIO_DATA);
+#else
+        //saa_andorb(GPIO_OUT_EN,mask,~mask);
+	saa_andorb(SAA7134_GPIO_27_25,0,~mask);
+	udelay(2500);
+	saa_andorb(SAA7134_GPIO_27_25,mask,~mask);
+#endif
+
+	printk(KERN_INFO "saa7134: SK Monster TV msp34xx: reset line "
+	       "init [%d]\n", pin);
+}
+
+
 static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
 				     const struct pci_device_id *pci_id)
 {
@@ -713,6 +741,11 @@
 	if (saa7134_boards[dev->board].need_tda9887)
 		request_module("tda9887");
 
+   	if (saa7134_boards[dev->board].need_msp34x5) {
+		request_module("msp34x5");
+		boot_msp34xx(dev,20); /* From bttv-cards.c */
+	}
+
 	/* register v4l devices */
 	dev->video_dev = saa7134_video_template;
 	dev->video_dev.priv = dev;
diff -urN saa7134-0.1.11/saa7134-tvaudio.c saa7134-0.1.11.monstertv1/saa7134-tvaudio.c
--- saa7134-0.1.11/saa7134-tvaudio.c	2002-09-02 20:00:55.000000000 +0900
+++ saa7134-0.1.11.monstertv1/saa7134-tvaudio.c	2002-10-11 00:45:53.000000000 +0900
@@ -31,6 +31,8 @@
 
 #include "saa7134-reg.h"
 #include "saa7134.h"
+#include "audiochip.h"
+#include <linux/i2c.h>
 
 /* ------------------------------------------------------------------ */
 
@@ -108,6 +110,12 @@
 		carr1:         4500,
 		carr2:         4724,
 		mode:          TVAUDIO_FM_K_STEREO,
+	},{
+		name:          "NTSC-EIA-J FM-stereo",
+		std:           V4L2_STD_NTSC,
+		carr1:         4500,
+		carr2:         4500,
+		mode:          TVAUDIO_FM_K_STEREO,
 	}
 };
 #define TVAUDIO (sizeof(tvaudio)/sizeof(struct saa7134_tvaudio))
@@ -153,6 +161,7 @@
 	struct saa7134_input *in;
 	int reg = 0;
 	int mask;
+        unsigned int sarg;
 
 	/* look what is to do ... */
 	in   = dev->input;
@@ -163,9 +172,19 @@
 			in = &card(dev).mute;
 	}
 	if (dev->hw_mute  == mute &&
-	    dev->hw_input == in)
-		return;
-
+	    dev->hw_input == in) {
+	   /* MSP34xx MUTE */
+	   if(card_has_msp(dev)) {
+	      struct video_audio varg;
+	      varg.flags=VIDEO_AUDIO_MUTE;
+	      varg.volume=0;
+	      varg.balance=32768;
+	      saa7134_i2c_call_clients(dev,VIDIOCGAUDIO,&varg);
+	      return;
+	   } else {
+	      return;
+	   }
+	}
 #if 1
 	dprintk("ctl_mute=%d automute=%d input=%s  =>  mute=%d input=%s\n",
 		dev->ctl_mute,dev->automute,dev->input->name,mute,in->name);
@@ -176,7 +195,6 @@
 	if (card_has_audio(dev))
 		/* 7134 mute */
 		saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ? 0xff : 0xbb);
-
 	/* switch internal audio mux */
 	switch (in->amux) {
 	case TV:    reg = 0x02; break;
@@ -184,7 +202,13 @@
 	case LINE2: reg = 0x01; break;
 	}
 	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x07, reg);
-
+        /* For Monster TV */
+#if 1
+        if((card_has_msp(dev))) {
+	      sarg=AUDIO_RADIO;
+	      saa7134_i2c_call_clients(dev,AUDC_SET_INPUT,&sarg);
+	}
+#endif
 	/* switch gpio-connected external audio mux */
 	if (0 == card(dev).gpiomask)
 		return;
@@ -197,6 +221,14 @@
 void saa7134_tvaudio_setmute(struct saa7134_dev *dev)
 {
 	saa7134_tvaudio_do_mute_input(dev);
+        /* MSP34xx MUTE */
+        if(card_has_msp(dev)) {
+	      struct video_audio varg;
+	      varg.flags=VIDEO_AUDIO_MUTE;
+	      varg.volume=0;
+	      varg.balance=32768;
+	      saa7134_i2c_call_clients(dev,VIDIOCGAUDIO,&varg);
+	 }
 }
 
 void saa7134_tvaudio_setinput(struct saa7134_dev *dev,
@@ -213,6 +245,8 @@
 	saa_writeb(SAA7134_NICAM_LEVEL_ADJUST, level & 0x1f);
 }
 
+
+
 static void tvaudio_setmode(struct saa7134_dev *dev,
 			    struct saa7134_tvaudio *audio,
 			    char *note)
@@ -233,7 +267,6 @@
 		saa_writeb(SAA7134_AUDIO_CLOCKS_PER_FIELD2, 0x02);
 	}
 	tvaudio_setcarrier(dev,audio->carr1,audio->carr2);
-	
 	switch (audio->mode) {
 	case TVAUDIO_FM_MONO:
 	case TVAUDIO_FM_BG_STEREO:
@@ -474,7 +507,9 @@
 
 int saa7134_tvaudio_init(struct saa7134_dev *dev)
 {
-	DECLARE_MUTEX_LOCKED(sem);
+
+ 
+   DECLARE_MUTEX_LOCKED(sem);
 
 	/* start tvaudio thread */
 	init_waitqueue_head(&dev->thread.wq);
@@ -499,6 +534,7 @@
 		saa_writeb(SAA7134_I2S_AUDIO_OUTPUT,   0x01);
 	}
 	return 0;
+
 }
 
 int saa7134_tvaudio_fini(struct saa7134_dev *dev)
diff -urN saa7134-0.1.11/saa7134-video.c saa7134-0.1.11.monstertv1/saa7134-video.c
--- saa7134-0.1.11/saa7134-video.c	2002-06-05 19:54:05.000000000 +0900
+++ saa7134-0.1.11.monstertv1/saa7134-video.c	2002-10-11 00:45:53.000000000 +0900
@@ -1228,6 +1228,7 @@
 	struct saa7134_video_fh *fh;
 	struct list_head *list;
 	int radio = 0;
+        unsigned int sarg;
 	
 	list_for_each(list,&saa7134_devlist) {
 		h = list_entry(list, struct saa7134_dev, devlist);
diff -urN saa7134-0.1.11/saa7134.h saa7134-0.1.11.monstertv1/saa7134.h
--- saa7134-0.1.11/saa7134.h	2002-08-09 02:01:08.000000000 +0900
+++ saa7134-0.1.11.monstertv1/saa7134.h	2002-10-11 00:45:53.000000000 +0900
@@ -155,11 +155,13 @@
 	/* i2c chip info */
 	int                     tuner_type;
 	int                     need_tda9887:1;
+        int                     need_msp34x5:1;
 };
 
 #define card_has_audio(dev)   (dev->pci->device == PCI_DEVICE_ID_PHILIPS_SAA7134)
 #define card_has_radio(dev)   (NULL != saa7134_boards[dev->board].radio.name)
 #define card_has_ts(dev)      (saa7134_boards[dev->board].has_ts)
+#define card_has_msp(dev)      (saa7134_boards[dev->board].need_msp34x5)
 #define card(dev)             (saa7134_boards[dev->board])
 #define card_in(dev,n)        (saa7134_boards[dev->board].inputs[n])
 
diff -urN saa7134-0.1.11/test-oss saa7134-0.1.11.monstertv1/test-oss
--- saa7134-0.1.11/test-oss	2002-01-15 02:04:15.000000000 +0900
+++ saa7134-0.1.11.monstertv1/test-oss	2002-10-11 00:45:53.000000000 +0900
@@ -1,7 +1,7 @@
 #!/bin/sh
 args="$*"
 
-v4l="/dev/video1"
+v4l="/dev/video0"
 dsp="/dev/dsp1"
 mix="/dev/mixer1"
 out="/dev/dsp"
diff -urN saa7134-0.1.11/tuner.c saa7134-0.1.11.monstertv1/tuner.c
--- saa7134-0.1.11/tuner.c	2002-10-08 18:28:39.000000000 +0900
+++ saa7134-0.1.11.monstertv1/tuner.c	2002-10-11 00:45:53.000000000 +0900
@@ -227,6 +227,9 @@
 	  16*160.00,16*442.00,0x01,0x02,0x04,0x8e,623 },
 	{ "LG NTSC (newer TAPC series)", LGINNOTEK, NTSC,
           16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,732},
+        { "Philips NTSC MK3 (FM1236MK3 or FM1236/F)", Philips, NTSC,
+          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732 },
+
 };
 #define TUNERS (sizeof(tuners)/sizeof(struct tunertype))
 
@@ -769,6 +772,7 @@
 	buffer[2] = tun->config;
 	switch (t->type) {
 	case TUNER_PHILIPS_FM1216ME_MK3:
+	case TUNER_PHILIPS_FM1236_MK3:
 		buffer[3] = 0x19;
 		break;
 	default:
diff -urN saa7134-0.1.11/tuner.c.orig saa7134-0.1.11.monstertv1/tuner.c.orig
--- saa7134-0.1.11/tuner.c.orig	1970-01-01 09:00:00.000000000 +0900
+++ saa7134-0.1.11.monstertv1/tuner.c.orig	2002-10-08 18:28:39.000000000 +0900
@@ -0,0 +1,1012 @@
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/timer.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <linux/i2c.h>
+#include <linux/types.h>
+#include <linux/videodev.h>
+#include <linux/init.h>
+
+#include "tuner.h"
+#include "audiochip.h"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = {I2C_CLIENT_END};
+static unsigned short normal_i2c_range[] = {0x60,0x6f,I2C_CLIENT_END};
+static unsigned short probe[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short probe_range[2]  = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short ignore[2]       = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
+static unsigned short force[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };
+static struct i2c_client_address_data addr_data = {
+	normal_i2c, normal_i2c_range, 
+	probe, probe_range, 
+	ignore, ignore_range, 
+	force
+};
+
+/* insmod options */
+static int debug =  0;
+static int type  = -1;
+static int addr  =  0;
+static char *pal =  "b";
+static int tv_range[2]    = { 44, 958 };
+static int radio_range[2] = { 65, 108 };
+MODULE_PARM(debug,"i");
+MODULE_PARM(type,"i");
+MODULE_PARM(addr,"i");
+MODULE_PARM(tv_range,"2i");
+MODULE_PARM(radio_range,"2i");
+MODULE_PARM(pal,"s");
+
+#define optimize_vco 1
+
+MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
+MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
+MODULE_LICENSE("GPL");
+
+static int this_adap;
+#define dprintk     if (debug) printk
+
+struct tuner
+{
+	int type;            /* chip type */
+	int freq;            /* keep track of the current settings */
+	int std;
+
+	int radio;
+	int mode;            /* current norm for multi-norm tuners */
+	int xogc;	     // only for MT2032
+};
+
+static struct i2c_driver driver;
+static struct i2c_client client_template;
+
+/* ---------------------------------------------------------------------- */
+
+/* tv standard selection for Temic 4046 FM5
+   this value takes the low bits of control byte 2
+   from datasheet Rev.01, Feb.00 
+     standard     BG      I       L       L2      D
+     picture IF   38.9    38.9    38.9    33.95   38.9
+     sound 1      33.4    32.9    32.4    40.45   32.4
+     sound 2      33.16   
+     NICAM        33.05   32.348  33.05           33.05
+ */
+#define TEMIC_SET_PAL_I         0x05
+#define TEMIC_SET_PAL_DK        0x09
+#define TEMIC_SET_PAL_L         0x0a // SECAM ?
+#define TEMIC_SET_PAL_L2        0x0b // change IF !
+#define TEMIC_SET_PAL_BG        0x0c
+
+/* tv tuner system standard selection for Philips FQ1216ME
+   this value takes the low bits of control byte 2
+   from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
+     standard 		BG	DK	I	L	L`
+     picture carrier	38.90	38.90	38.90	38.90	33.95
+     colour		34.47	34.47	34.47	34.47	38.38
+     sound 1		33.40	32.40	32.90	32.40	40.45
+     sound 2		33.16	-	-	-	-
+     NICAM		33.05	33.05	32.35	33.05	39.80
+ */
+#define PHILIPS_SET_PAL_I	0x01 /* Bit 2 always zero !*/
+#define PHILIPS_SET_PAL_BGDK	0x09
+#define PHILIPS_SET_PAL_L2	0x0a
+#define PHILIPS_SET_PAL_L	0x0b	
+
+/* system switching for Philips FI1216MF MK2
+   from datasheet "1996 Jul 09",
+    standard         BG     L      L'
+    picture carrier  38.90  38.90  33.95
+    colour	     34.47  34.37  38.38
+    sound 1          33.40  32.40  40.45
+    sound 2          33.16  -      -
+    NICAM            33.05  33.05  39.80
+ */
+#define PHILIPS_MF_SET_BG	0x01 /* Bit 2 must be zero, Bit 3 is system output */
+#define PHILIPS_MF_SET_PAL_L	0x03 // France
+#define PHILIPS_MF_SET_PAL_L2	0x02 // L'
+
+
+/* ---------------------------------------------------------------------- */
+
+struct tunertype 
+{
+	char *name;
+	unsigned char Vendor;
+	unsigned char Type;
+  
+	unsigned short thresh1;  /*  band switch VHF_LO <=> VHF_HI  */
+	unsigned short thresh2;  /*  band switch VHF_HI <=> UHF     */
+	unsigned char VHF_L;
+	unsigned char VHF_H;
+	unsigned char UHF;
+	unsigned char config; 
+	unsigned short IFPCoff; /* 622.4=16*38.90 MHz PAL, 
+				   732  =16*45.75 NTSCi, 
+				   940  =58.75 NTSC-Japan */
+};
+
+/*
+ *	The floats in the tuner struct are computed at compile time
+ *	by gcc and cast back to integers. Thus we don't violate the
+ *	"no float in kernel" rule.
+ */
+static struct tunertype tuners[] = {
+        { "Temic PAL (4002 FH5)", TEMIC, PAL,
+	  16*140.25,16*463.25,0x02,0x04,0x01,0x8e,623},
+	{ "Philips PAL_I (FI1246 and compatibles)", Philips, PAL_I,
+	  16*140.25,16*463.25,0xa0,0x90,0x30,0x8e,623},
+	{ "Philips NTSC (FI1236 and compatibles)", Philips, NTSC,
+	  16*157.25,16*451.25,0xA0,0x90,0x30,0x8e,732},
+	{ "Philips (SECAM+PAL_BG) (FI1216MF, FM1216MF, FR1216MF)", Philips, SECAM,
+	  16*168.25,16*447.25,0xA7,0x97,0x37,0x8e,623},
+
+	{ "NoTuner", NoTuner, NOTUNER,
+	  0,0,0x00,0x00,0x00,0x00,0x00},
+	{ "Philips PAL_BG (FI1216 and compatibles)", Philips, PAL,
+	  16*168.25,16*447.25,0xA0,0x90,0x30,0x8e,623},
+	{ "Temic NTSC (4032 FY5)", TEMIC, NTSC,
+	  16*157.25,16*463.25,0x02,0x04,0x01,0x8e,732},
+	{ "Temic PAL_I (4062 FY5)", TEMIC, PAL_I,
+	  16*170.00,16*450.00,0x02,0x04,0x01,0x8e,623},
+
+ 	{ "Temic NTSC (4036 FY5)", TEMIC, NTSC,
+	  16*157.25,16*463.25,0xa0,0x90,0x30,0x8e,732},
+        { "Alps HSBH1", TEMIC, NTSC,
+	  16*137.25,16*385.25,0x01,0x02,0x08,0x8e,732},
+        { "Alps TSBE1",TEMIC,PAL,
+	  16*137.25,16*385.25,0x01,0x02,0x08,0x8e,732},
+        { "Alps TSBB5", Alps, PAL_I, /* tested (UK UHF) with Modulartech MM205 */
+	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,632},
+
+        { "Alps TSBE5", Alps, PAL, /* untested - data sheet guess. Only IF differs. */
+	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,622},
+        { "Alps TSBC5", Alps, PAL, /* untested - data sheet guess. Only IF differs. */
+	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,608},
+	{ "Temic PAL_BG (4006FH5)", TEMIC, PAL,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623}, 
+  	{ "Alps TSCH6",Alps,NTSC,
+  	  16*137.25,16*385.25,0x14,0x12,0x11,0x8e,732},
+
+  	{ "Temic PAL_DK (4016 FY5)",TEMIC,PAL,
+  	  16*168.25,16*456.25,0xa0,0x90,0x30,0x8e,623},
+  	{ "Philips NTSC_M (MK2)",Philips,NTSC,
+  	  16*160.00,16*454.00,0xa0,0x90,0x30,0x8e,732},
+        { "Temic PAL_I (4066 FY5)", TEMIC, PAL_I,
+          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
+        { "Temic PAL* auto (4006 FN5)", TEMIC, PAL,
+          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
+
+        { "Temic PAL_BG (4009 FR5) or PAL_I (4069 FR5)", TEMIC, PAL,
+          16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
+        { "Temic NTSC (4039 FR5)", TEMIC, NTSC,
+          16*158.00, 16*453.00, 0xa0,0x90,0x30,0x8e,732},
+        { "Temic PAL/SECAM multi (4046 FM5)", TEMIC, PAL,
+          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
+        { "Philips PAL_DK (FI1256 and compatibles)", Philips, PAL,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
+
+	{ "Philips PAL/SECAM multi (FQ1216ME)", Philips, PAL,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
+	{ "LG PAL_I+FM (TAPC-I001D)", LGINNOTEK, PAL_I,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
+	{ "LG PAL_I (TAPC-I701D)", LGINNOTEK, PAL_I,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
+	{ "LG NTSC+FM (TPI8NSR01F)", LGINNOTEK, NTSC,
+	  16*210.00,16*497.00,0xa0,0x90,0x30,0x8e,732},
+
+	{ "LG PAL_BG+FM (TPI8PSB01D)", LGINNOTEK, PAL,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
+	{ "LG PAL_BG (TPI8PSB11D)", LGINNOTEK, PAL,
+	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
+	{ "Temic PAL* auto + FM (4009 FN5)", TEMIC, PAL,
+	  16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
+	{ "SHARP NTSC_JP (2U5JF5540)", SHARP, NTSC, /* 940=16*58.75 NTSC@Japan */
+	  16*137.25,16*317.25,0x01,0x02,0x08,0x8e,732 }, // Corrected to NTSC=732 (was:940)
+
+	{ "Samsung PAL TCPM9091PD27", Samsung, PAL,  /* from sourceforge v3tv */
+          16*169,16*464,0xA0,0x90,0x30,0x8e,623},
+	{ "MT2032 universal", Microtune,PAL|NTSC,
+               0,0,0,0,0,0,0},
+	{ "Temic PAL_BG (4106 FH5)", TEMIC, PAL,
+          16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
+	{ "Temic PAL_DK/SECAM_L (4012 FY5)", TEMIC, PAL,
+          16*140.25, 16*463.25, 0x02,0x04,0x01,0x8e,623},
+
+	{ "Temic NTSC (4136 FY5)", TEMIC, NTSC,
+          16*158.00, 16*453.00, 0xa0,0x90,0x30,0x8e,732},
+        { "LG PAL (newer TAPC series)", LGINNOTEK, PAL,
+          16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,623},
+	{ "Philips PAL/SECAM multi (FM1216ME MK3)", Philips, PAL,
+	  16*160.00,16*442.00,0x01,0x02,0x04,0x8e,623 },
+	{ "LG NTSC (newer TAPC series)", LGINNOTEK, NTSC,
+          16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,732},
+};
+#define TUNERS (sizeof(tuners)/sizeof(struct tunertype))
+
+/* ---------------------------------------------------------------------- */
+
+static int tuner_getstatus(struct i2c_client *c)
+{
+	unsigned char byte;
+
+	struct tuner *t = (struct tuner*)c->data;
+
+        if (t->type == TUNER_MT2032)
+		return 0;
+
+	if (1 != i2c_master_recv(c,&byte,1))
+		return 0;
+	return byte;
+}
+
+#define TUNER_POR       0x80
+#define TUNER_FL        0x40
+#define TUNER_MODE      0x38
+#define TUNER_AFC       0x07
+
+#define TUNER_STEREO    0x10 /* radio mode */
+#define TUNER_SIGNAL    0x07 /* radio mode */
+
+static int tuner_signal(struct i2c_client *c)
+{
+	return (tuner_getstatus(c) & TUNER_SIGNAL)<<13;
+}
+
+static int tuner_stereo(struct i2c_client *c)
+{
+	return (tuner_getstatus (c) & TUNER_STEREO);
+}
+
+#if 0 /* unused */
+static int tuner_islocked (struct i2c_client *c)
+{
+        return (tuner_getstatus (c) & TUNER_FL);
+}
+
+static int tuner_afcstatus (struct i2c_client *c)
+{
+        return (tuner_getstatus (c) & TUNER_AFC) - 2;
+}
+
+static int tuner_mode (struct i2c_client *c)
+{
+        return (tuner_getstatus (c) & TUNER_MODE) >> 3;
+}
+#endif
+
+// Initalization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
+static int mt2032_init(struct i2c_client *c)
+{
+        unsigned char buf[21];
+        int ret,xogc,xok=0;
+	struct tuner *t = (struct tuner*)c->data;
+
+        buf[0]=0;
+        ret=i2c_master_send(c,buf,1);
+        i2c_master_recv(c,buf,21);
+
+        printk("MT2032: Companycode=%02x%02x Part=%02x Revision=%02x\n",
+                buf[0x11],buf[0x12],buf[0x13],buf[0x14]);
+
+        if(debug) {
+                int i;
+                printk("MT2032 hexdump:\n");
+                for(i=0;i<21;i++) {
+                        printk(" %02x",buf[i]);
+                        if(((i+1)%8)==0) printk(" ");
+                        if(((i+1)%16)==0) printk("\n ");
+                }
+                printk("\n ");
+        }
+	// Look for MT2032 id:
+	// part= 0x04(MT2032), 0x06(MT2030), 0x07(MT2040)
+        if((buf[0x11] != 0x4d) || (buf[0x12] != 0x54) || (buf[0x13] != 0x04)) {
+                printk("not a MT2032.\n");
+                return 0;
+        }
+
+
+        // Initialize Registers per spec.
+        buf[1]=2; // Index to register 2
+        buf[2]=0xff;
+        buf[3]=0x0f;
+        buf[4]=0x1f;
+        ret=i2c_master_send(c,buf+1,4);
+
+        buf[5]=6; // Index register 6
+        buf[6]=0xe4;
+        buf[7]=0x8f;
+        buf[8]=0xc3;
+        buf[9]=0x4e;
+        buf[10]=0xec;
+        ret=i2c_master_send(c,buf+5,6);
+
+        buf[12]=13;  // Index register 13
+        buf[13]=0x32;
+        ret=i2c_master_send(c,buf+12,2);
+
+        // Adjust XOGC (register 7), wait for XOK
+        xogc=7;
+        do {
+		dprintk("mt2032: xogc = 0x%02x\n",xogc&0x07);
+                mdelay(10);
+                buf[0]=0x0e;
+                i2c_master_send(c,buf,1);
+                i2c_master_recv(c,buf,1);
+                xok=buf[0]&0x01;
+                dprintk("mt2032: xok = 0x%02x\n",xok);
+                if (xok == 1) break;
+
+                xogc--;
+                dprintk("mt2032: xogc = 0x%02x\n",xogc&0x07);
+                if (xogc == 3) {
+                        xogc=4; // min. 4 per spec
+                        break;
+                }
+                buf[0]=0x07;
+                buf[1]=0x88 + xogc;
+                ret=i2c_master_send(c,buf,2);
+                if (ret!=2)
+                        printk("mt2032_init failed with %d\n",ret);
+        } while (xok != 1 );
+	t->xogc=xogc;
+
+        return(1);
+}
+
+
+// IsSpurInBand()?
+static int mt2032_spurcheck(int f1, int f2, int spectrum_from,int spectrum_to)
+{
+	int n1=1,n2,f;
+
+	f1=f1/1000; //scale to kHz to avoid 32bit overflows
+	f2=f2/1000;
+	spectrum_from/=1000;
+	spectrum_to/=1000;
+
+	dprintk("spurcheck f1=%d f2=%d  from=%d to=%d\n",f1,f2,spectrum_from,spectrum_to);
+
+	do {
+	    n2=-n1;
+	    f=n1*(f1-f2);
+	    do {
+		n2--;
+		f=f-f2;
+		dprintk(" spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);
+
+		if( (f>spectrum_from) && (f<spectrum_to))
+			printk("mt2032 spurcheck triggered: %d\n",n1);
+	    } while ( (f>(f2-spectrum_to)) || (n2>-5));
+	    n1++;
+	} while (n1<5);
+
+	return 1;
+}
+
+static int mt2032_compute_freq(int rfin, int if1, int if2, int spectrum_from,
+	int spectrum_to, unsigned char *buf, int *ret_sel, int xogc) //all in Hz
+{
+        int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
+		desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;
+
+        fref= 5250 *1000; //5.25MHz
+	desired_lo1=rfin+if1;
+
+	lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
+        lo1n=lo1/8;
+        lo1a=lo1-(lo1n*8);
+
+        s=rfin/1000/1000+1090;
+
+	if(optimize_vco) {
+		if(s>1890) sel=0;
+		else if(s>1720) sel=1;
+		else if(s>1530) sel=2;
+		else if(s>1370) sel=3;
+		else sel=4; // >1090
+	}
+	else {
+        	if(s>1790) sel=0; // <1958
+        	else if(s>1617) sel=1;
+        	else if(s>1449) sel=2;
+        	else if(s>1291) sel=3;
+        	else sel=4; // >1090
+	}
+	*ret_sel=sel;
+
+        lo1freq=(lo1a+8*lo1n)*fref;
+
+        dprintk("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
+		rfin,lo1,lo1n,lo1a,sel,lo1freq);
+
+        desired_lo2=lo1freq-rfin-if2;
+        lo2=(desired_lo2)/fref;
+        lo2n=lo2/8;
+        lo2a=lo2-(lo2n*8);
+        lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
+        lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;
+
+        dprintk("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
+		rfin,lo2,lo2n,lo2a,lo2num,lo2freq);
+
+        if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
+                printk("mt2032: frequency parameters out of range: %d %d %d %d\n",
+		       lo1a, lo1n, lo2a,lo2n);
+                return(-1);
+        }
+
+	mt2032_spurcheck(lo1freq, desired_lo2,  spectrum_from, spectrum_to);
+	// should recalculate lo1 (one step up/down)
+
+	// set up MT2032 register map for transfer over i2c
+	buf[0]=lo1n-1;
+	buf[1]=lo1a | (sel<<4);
+	buf[2]=0x86; // LOGC
+	buf[3]=0x0f; //reserved
+	buf[4]=0x1f;
+	buf[5]=(lo2n-1) | (lo2a<<5);
+ 	if(rfin >400*1000*1000)
+                buf[6]=0xe4;
+        else
+                buf[6]=0xf4; // set PKEN per rev 1.2 
+	buf[7]=8+xogc;
+	buf[8]=0xc3; //reserved
+	buf[9]=0x4e; //reserved
+	buf[10]=0xec; //reserved
+	buf[11]=(lo2num&0xff);
+	buf[12]=(lo2num>>8) |0x80; // Lo2RST
+
+	return 0;
+}
+
+static int mt2032_check_lo_lock(struct i2c_client *c)
+{
+	int try,lock=0;
+	unsigned char buf[2];
+	for(try=0;try<10;try++) {
+		buf[0]=0x0e;
+		i2c_master_send(c,buf,1);
+		i2c_master_recv(c,buf,1);
+		dprintk("mt2032 Reg.E=0x%02x\n",buf[0]);
+		lock=buf[0] &0x06;
+		
+		if (lock==6)
+			break;
+		
+		dprintk("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
+		udelay(1000);
+	}
+        return lock;
+}
+
+static int mt2032_optimize_vco(struct i2c_client *c,int sel,int lock)
+{
+	unsigned char buf[2];
+	int tad1;
+
+	buf[0]=0x0f;
+	i2c_master_send(c,buf,1);
+	i2c_master_recv(c,buf,1);
+	dprintk("mt2032 Reg.F=0x%02x\n",buf[0]);
+	tad1=buf[0]&0x07;
+
+	if(tad1 ==0) return lock;
+	if(tad1 ==1) return lock;
+
+	if(tad1==2) {
+		if(sel==0) 
+			return lock;
+		else sel--;
+	}
+	else {
+		if(sel<4)
+			sel++;
+		else
+			return lock;
+	}
+
+	dprintk("mt2032 optimize_vco: sel=%d\n",sel);
+
+	buf[0]=0x0f;
+	buf[1]=sel;
+        i2c_master_send(c,buf,2);
+	lock=mt2032_check_lo_lock(c);
+	return lock;
+}
+
+
+static void mt2032_set_if_freq(struct i2c_client *c,int rfin, int if1, int if2, int from, int to)
+{
+	unsigned char buf[21];
+	int lint_try,ret,sel,lock=0;
+	struct tuner *t = (struct tuner*)c->data;
+
+	dprintk("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",rfin,if1,if2,from,to);
+
+        buf[0]=0;
+        ret=i2c_master_send(c,buf,1);
+        i2c_master_recv(c,buf,21);
+
+	buf[0]=0;
+	ret=mt2032_compute_freq(rfin,if1,if2,from,to,&buf[1],&sel,t->xogc);
+	if (ret<0)
+		return;
+
+        // send only the relevant registers per Rev. 1.2
+        buf[0]=0;
+        ret=i2c_master_send(c,buf,4);
+        buf[5]=5;
+        ret=i2c_master_send(c,buf+5,4);
+        buf[11]=11;
+        ret=i2c_master_send(c,buf+11,3);
+        if(ret!=3)
+                printk("mt2032_set_if_freq failed with %d\n",ret);
+
+	// wait for PLLs to lock (per manual), retry LINT if not.
+	for(lint_try=0; lint_try<2; lint_try++) {
+		lock=mt2032_check_lo_lock(c);
+		
+		if(optimize_vco)
+			lock=mt2032_optimize_vco(c,sel,lock);
+		if(lock==6) break;
+		
+		printk("mt2032: re-init PLLs by LINT\n"); 
+		buf[0]=7; 
+		buf[1]=0x80 +8+t->xogc; // set LINT to re-init PLLs
+		i2c_master_send(c,buf,2);
+		mdelay(10);
+		buf[1]=8+t->xogc;
+		i2c_master_send(c,buf,2);
+        }
+
+	if (lock!=6)
+		printk("MT2032 Fatal Error: PLLs didn't lock.\n");
+
+	buf[0]=2;
+	buf[1]=0x20; // LOGC for optimal phase noise
+	ret=i2c_master_send(c,buf,2);
+	if (ret!=2)
+		printk("mt2032_set_if_freq2 failed with %d\n",ret);
+}
+
+
+static void mt2032_set_tv_freq(struct i2c_client *c, int freq, int norm)
+{
+	int if2,from,to;
+
+	// signal bandwidth and picture carrier
+	if(norm==VIDEO_MODE_NTSC) {
+		from=40750*1000;
+		to=46750*1000;
+		if2=45750*1000; 
+	}
+	else {  // Pal 
+		from=32900*1000;
+		to=39900*1000;
+		if2=38900*1000;
+	}
+
+        mt2032_set_if_freq(c,freq* 1000*1000/16, 1090*1000*1000, if2, from, to);
+}
+
+
+// Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz
+static void set_tv_freq(struct i2c_client *c, int freq)
+{
+	u8 config;
+	u16 div;
+	struct tunertype *tun;
+	struct tuner *t = c->data;
+        unsigned char buffer[4];
+	int rc;
+
+	if (t->type == -1) {
+		printk("tuner: tuner type not set\n");
+		return;
+	}
+	if (t->type == TUNER_MT2032) {
+		mt2032_set_tv_freq(c,freq,t->mode);
+		return;
+	}
+
+	if (freq < tv_range[0]*16 || freq > tv_range[1]*16) {
+		/* FIXME: better do that chip-specific, but
+		   right now we don't have that in the config
+		   struct and this way is still better than no
+		   check at all */
+		printk("tuner: TV freq (%d.%02d) out of range (%d-%d)\n",
+		       freq/16,freq%16*100/16,tv_range[0],tv_range[1]);
+		return;
+	}
+
+	tun=&tuners[t->type];
+	if (freq < tun->thresh1) 
+		config = tun->VHF_L;
+	else if (freq < tun->thresh2) 
+		config = tun->VHF_H;
+	else
+		config = tun->UHF;
+
+
+	/* tv norm specific stuff for multi-norm tuners */
+	switch (t->type) {
+	case TUNER_PHILIPS_SECAM: // FI1216MF
+		/* 0x01 -> ??? no change ??? */
+		/* 0x02 -> PAL BDGHI / SECAM L */
+		/* 0x04 -> ??? PAL others / SECAM others ??? */
+		config &= ~0x02;
+		if (t->mode == VIDEO_MODE_SECAM)
+			config |= 0x02;
+		break;
+
+	case TUNER_TEMIC_4046FM5:
+		config &= ~0x0f;
+		switch (pal[0]) {
+		case 'i':
+		case 'I':
+			config |= TEMIC_SET_PAL_I;
+			break;
+		case 'd':
+		case 'D':
+			config |= TEMIC_SET_PAL_DK;
+			break;
+		case 'l':
+		case 'L':
+			config |= TEMIC_SET_PAL_L;
+			break;
+		case 'b':
+		case 'B':
+		case 'g':
+		case 'G':
+		default:
+			config |= TEMIC_SET_PAL_BG;
+			break;
+		}
+		break;
+
+	case TUNER_PHILIPS_FQ1216ME:
+		config &= ~0x0f;
+		switch (pal[0]) {
+		case 'i':
+		case 'I':
+			config |= PHILIPS_SET_PAL_I;
+			break;
+		case 'l':
+		case 'L':
+			config |= PHILIPS_SET_PAL_L;
+			break;
+		case 'd':
+		case 'D':
+		case 'b':
+		case 'B':
+		case 'g':
+		case 'G':
+			config |= PHILIPS_SET_PAL_BGDK;
+			break;
+		}
+		break;
+	}
+
+	
+	/*
+	 * Philips FI1216MK2 remark from specification :
+	 * for channel selection involving band switching, and to ensure
+	 * smooth tuning to the desired channel without causing
+	 * unnecessary charge pump action, it is recommended to consider
+	 * the difference between wanted channel frequency and the
+	 * current channel frequency.  Unnecessary charge pump action
+	 * will result in very low tuning voltage which may drive the
+	 * oscillator to extreme conditions.
+	 *
+	 * Progfou: specification says to send config data before
+	 * frequency in case (wanted frequency < current frequency).
+	 */
+
+	div=freq + tun->IFPCoff;
+	if (t->type == TUNER_PHILIPS_SECAM && freq < t->freq) {
+		buffer[0] = tun->config;
+		buffer[1] = config;
+		buffer[2] = (div>>8) & 0x7f;
+		buffer[3] = div      & 0xff;
+	} else {
+		buffer[0] = (div>>8) & 0x7f;
+		buffer[1] = div      & 0xff;
+		buffer[2] = tun->config;
+		buffer[3] = config;
+	}
+	dprintk("tuner: tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
+		buffer[0],buffer[1],buffer[2],buffer[3]);
+
+        if (4 != (rc = i2c_master_send(c,buffer,4)))
+                printk("tuner: i2c i/o error: rc == %d (should be 4)\n",rc);
+
+}
+
+static void mt2032_set_radio_freq(struct i2c_client *c,int freq)
+{               
+        int if2;
+
+        if2=10700*1000; //  10.7MHz FM intermediate frequency
+
+        mt2032_set_if_freq(c,freq* 1000*1000/16, 1085*1000*1000,if2,if2,if2);
+}
+
+static void set_radio_freq(struct i2c_client *c, int freq)
+{
+	struct tunertype *tun;
+	struct tuner *t = (struct tuner*)c->data;
+        unsigned char buffer[4];
+	int rc,div;
+
+	if (freq < radio_range[0]*16 || freq > radio_range[1]*16) {
+		printk("tuner: radio freq (%d.%02d) out of range (%d-%d)\n",
+		       freq/16,freq%16*100/16,
+		       radio_range[0],radio_range[1]);
+		return;
+	}
+	if (t->type == -1) {
+		printk("tuner: tuner type not set\n");
+		return;
+	}
+
+        if (t->type == TUNER_MT2032) {
+                mt2032_set_radio_freq(c,freq);
+		return;
+	}
+
+	tun=&tuners[t->type];
+	div = freq + (int)(16*10.7);
+        buffer[0] = (div>>8) & 0x7f;
+        buffer[1] = div      & 0xff;
+	buffer[2] = tun->config;
+	switch (t->type) {
+	case TUNER_PHILIPS_FM1216ME_MK3:
+		buffer[3] = 0x19;
+		break;
+	default:
+		buffer[3] = 0xa4;
+		break;
+	}
+
+	dprintk("tuner: radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
+		buffer[0],buffer[1],buffer[2],buffer[3]);
+
+        if (4 != (rc = i2c_master_send(c,buffer,4)))
+                printk("tuner: i2c i/o error: rc == %d (should be 4)\n",rc);
+}
+
+/* ---------------------------------------------------------------------- */
+
+static int tuner_attach(struct i2c_adapter *adap, int addr,
+			unsigned short flags, int kind)
+{
+	struct tuner *t;
+	struct i2c_client *client;
+
+	if (this_adap > 0)
+		return -1;
+	this_adap++;
+	
+        client_template.adapter = adap;
+        client_template.addr = addr;
+
+        printk("tuner: chip found @ 0x%x\n", addr<<1);
+
+        if (NULL == (client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL)))
+                return -ENOMEM;
+        memcpy(client,&client_template,sizeof(struct i2c_client));
+        client->data = t = kmalloc(sizeof(struct tuner),GFP_KERNEL);
+        if (NULL == t) {
+                kfree(client);
+                return -ENOMEM;
+        }
+        memset(t,0,sizeof(struct tuner));
+	if (type >= 0 && type < TUNERS) {
+		t->type = type;
+		strncpy(client->name, tuners[t->type].name, sizeof(client->name));
+	} else {
+		t->type = -1;
+	}
+        i2c_attach_client(client);
+        if (t->type == TUNER_MT2032)
+                 mt2032_init(client);
+
+	MOD_INC_USE_COUNT;
+
+	return 0;
+}
+
+static int tuner_probe(struct i2c_adapter *adap)
+{
+	int rc;
+
+	if (0 != addr) {
+		normal_i2c_range[0] = addr;
+		normal_i2c_range[1] = addr;
+	}
+	this_adap = 0;
+	switch (adap->id) {
+	case I2C_ALGO_BIT | I2C_HW_B_BT848:
+	case I2C_ALGO_BIT | I2C_HW_B_RIVA:
+	case I2C_ALGO_SAA7134:
+		printk("tuner: probing %s i2c adapter [id=0x%x]\n",
+		       adap->name,adap->id);
+		rc = i2c_probe(adap, &addr_data, tuner_attach);
+		break;
+	default:
+		printk("tuner: ignoring %s i2c adapter [id=0x%x]\n",
+		       adap->name,adap->id);
+		rc = 0;
+		/* nothing */
+	}
+	return rc;
+}
+
+static int tuner_detach(struct i2c_client *client)
+{
+	struct tuner *t = (struct tuner*)client->data;
+
+	i2c_detach_client(client);
+	kfree(t);
+	kfree(client);
+	MOD_DEC_USE_COUNT;
+	return 0;
+}
+
+static int
+tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
+{
+	struct tuner *t = (struct tuner*)client->data;
+        int   *iarg = (int*)arg;
+#if 0
+        __u16 *sarg = (__u16*)arg;
+#endif
+
+        switch (cmd) {
+
+	/* --- configuration --- */
+	case TUNER_SET_TYPE:
+		if (t->type != -1) {
+			printk("tuner: type already set\n");
+			return 0;
+		}
+		if (*iarg < 0 || *iarg >= TUNERS)
+			return 0;
+		t->type = *iarg;
+		printk("tuner: type set to %d (%s)\n",
+                        t->type,tuners[t->type].name);
+		strncpy(client->name, tuners[t->type].name, sizeof(client->name));
+		if (t->type == TUNER_MT2032)
+                        mt2032_init(client);
+		break;
+	case AUDC_SET_RADIO:
+		t->radio = 1;
+		break;
+		
+	/* --- v4l ioctls --- */
+	/* take care: bttv does userspace copying, we'll get a
+	   kernel pointer here... */
+	case VIDIOCSCHAN:
+	{
+		struct video_channel *vc = arg;
+
+		t->radio = 0;
+		t->mode = vc->norm;
+		if (t->freq)
+			set_tv_freq(client,t->freq);
+		return 0;
+	}
+	case VIDIOCSFREQ:
+	{
+		unsigned long *v = arg;
+
+		if (t->radio) {
+			dprintk("tuner: radio freq set to %d.%02d\n",
+				(*iarg)/16,(*iarg)%16*100/16);
+			set_radio_freq(client,*v);
+		} else {
+			dprintk("tuner: tv freq set to %d.%02d\n",
+				(*iarg)/16,(*iarg)%16*100/16);
+			set_tv_freq(client,*v);
+		}
+		t->freq = *v;
+		return 0;
+	}
+	case VIDIOCGTUNER:
+	{
+		struct video_tuner *vt = arg;
+
+		if (t->radio)
+			vt->signal = tuner_signal(client);
+		return 0;
+	}
+	case VIDIOCGAUDIO:
+	{
+		struct video_audio *va = arg;
+		if (t->radio)
+			va->mode = (tuner_stereo(client) ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO);
+		return 0;
+	}
+	
+#if 0
+	/* --- old, obsolete interface --- */
+	case TUNER_SET_TVFREQ:
+		dprintk("tuner: tv freq set to %d.%02d\n",
+			(*iarg)/16,(*iarg)%16*100/16);
+		set_tv_freq(client,*iarg);
+		t->radio = 0;
+		t->freq = *iarg;
+		break;
+
+	case TUNER_SET_RADIOFREQ:
+		dprintk("tuner: radio freq set to %d.%02d\n",
+			(*iarg)/16,(*iarg)%16*100/16);
+		set_radio_freq(client,*iarg);
+		t->radio = 1;
+		t->freq = *iarg;
+		break;
+	case TUNER_SET_MODE:
+		if (t->type != TUNER_PHILIPS_SECAM) {
+			dprintk("tuner: trying to change mode for other than TUNER_PHILIPS_SECAM\n");
+		} else {
+			int mode=(*sarg==VIDEO_MODE_SECAM)?1:0;
+			dprintk("tuner: mode set to %d\n", *sarg);
+			t->mode = mode;
+			set_tv_freq(client,t->freq);
+		}
+		break;
+#endif
+	default:
+		/* nothing */
+		break;
+	}
+	
+	return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+static struct i2c_driver driver = {
+        name:           "i2c TV tuner driver",
+        id:             I2C_DRIVERID_TUNER,
+        flags:          I2C_DF_NOTIFY,
+        attach_adapter: tuner_probe,
+        detach_client:  tuner_detach,
+        command:        tuner_command,
+};
+static struct i2c_client client_template =
+{
+        name:   "(tuner unset)",
+	flags:  I2C_CLIENT_ALLOW_USE,
+        driver: &driver,
+};
+
+static int tuner_init_module(void)
+{
+	i2c_add_driver(&driver);
+	return 0;
+}
+
+static void tuner_cleanup_module(void)
+{
+	i2c_del_driver(&driver);
+}
+
+module_init(tuner_init_module);
+module_exit(tuner_cleanup_module);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff -urN saa7134-0.1.11/tuner.h saa7134-0.1.11.monstertv1/tuner.h
--- saa7134-0.1.11/tuner.h	2002-10-08 18:28:39.000000000 +0900
+++ saa7134-0.1.11.monstertv1/tuner.h	2002-10-11 00:45:53.000000000 +0900
@@ -64,6 +64,7 @@
 #define TUNER_LG_PAL_NEW_TAPC   37
 #define TUNER_PHILIPS_FM1216ME_MK3  38
 #define TUNER_LG_NTSC_NEW_TAPC   39
+#define TUNER_PHILIPS_FM1236_MK3  40
 
 
 
diff -urN saa7134-0.1.11/update saa7134-0.1.11.monstertv1/update
--- saa7134-0.1.11/update	2002-07-15 23:15:02.000000000 +0900
+++ saa7134-0.1.11.monstertv1/update	2002-10-11 00:45:53.000000000 +0900
@@ -1,6 +1,6 @@
 #!/bin/sh
 dir=`pwd`
-v4l="/dev/video1"
+v4l="/dev/video0"
 set -ex
 
 grep -q saa7134 /proc/modules		&& sudo /sbin/rmmod saa7134
@@ -8,6 +8,7 @@
 grep -q video-buf /proc/modules		&& sudo /sbin/rmmod video-buf
 grep -q tuner   /proc/modules		&& sudo /sbin/rmmod tuner
 grep -q tda9887   /proc/modules		&& sudo /sbin/rmmod tda9887
+grep -q msp34x5   /proc/modules		&& sudo /sbin/rmmod msp34x5
 
 grep -q v4l2-common /proc/modules	|| sudo /sbin/insmod v4l2-common
 grep -q v4l1-compat /proc/modules	|| sudo /sbin/insmod v4l1-compat
@@ -16,20 +17,26 @@
 sudo /sbin/insmod $dir/tuner.o	\
 	debug=1
 
-sudo /sbin/insmod $dir/tda9887.o \
-	debug=1
+#sudo /sbin/insmod $dir/tda9887.o \
+#	debug=1
+
+#grep -q bttv /proc/modules		|| sudo /sbin/insmod bttv
+
+#sudo /sbin/insmod $dir/msp34x5.o	\
+#	debug=1 \
+#	dolby=1
 
-grep -q bttv /proc/modules		|| sudo /sbin/insmod bttv
 
 sudo /sbin/insmod $dir/saa7134.o \
 	irq_debug=0	\
 	core_debug=0	\
 	video_debug=0	\
-	audio_debug=1	\
+	audio_debug=0	\
 	vbi_debug=0	\
 	oss_debug=0	\
 	i2c_debug=0	\
-	i2c_scan=1	\
-	card=7
+	i2c_scan=0	\
+	gpio_tracking=1 \
+	latency=80
 
-v4lctl -c $v4l setstation orb
+v4lctl -c $v4l setstation 1
