Changes to support dst and bttv > 0.9.12 and for kernel >= 2.6.0-test7

This has support for i2c doen by bttv. Tested and working in 2.4,
clean compile 2.6. Expect changes to get working under 2.6.

Patches directory no longer needed.

5 files changed, 438 insertions, 112 deletions

diff --git a/linux/drivers/media/dvb/bt8xx/Kconfig b/linux/drivers/media/dvb/bt8xx/Kconfig
index 73158550d..572bd491c 100644
--- a/linux/drivers/media/dvb/bt8xx/Kconfig
+++ b/linux/drivers/media/dvb/bt8xx/Kconfig
@@ -3,11 +3,11 @@ config DVB_BT8XX
 	depends on DVB_CORE && PCI && VIDEO_BT848
 	help
 	  Support for PCI cards based on the Bt8xx PCI bridge. Examples are
-	  The Nebula cards and the Pinnacle PCTV cards.
+	  the Nebula cards, the Pinnacle PCTV cards, and Twinhan DST cards.
 
           Since these cards have no MPEG decoder onboard, they transmit
 	  only compressed MPEG data over the PCI bus, so you need
-	  an external software decoder to watch TV on your computer.	  
+	  an external software decoder to watch TV on your computer.
 
 	  Say Y if you own such a device and want to use it.
 
diff --git a/linux/drivers/media/dvb/bt8xx/bt878.c b/linux/drivers/media/dvb/bt8xx/bt878.c
index 09c5dd38f..6d8939782 100644
--- a/linux/drivers/media/dvb/bt8xx/bt878.c
+++ b/linux/drivers/media/dvb/bt8xx/bt878.c
@@ -60,23 +60,13 @@ MODULE_LICENSE("GPL");
 int bt878_num;
 struct bt878 bt878[BT878_MAX];
 
-EXPORT_SYMBOL(bt878_num);
-EXPORT_SYMBOL(bt878);
+EXPORT_SYMBOL_GPL(bt878_debug);
+EXPORT_SYMBOL_GPL(bt878_verbose);
+EXPORT_SYMBOL_GPL(bt878_num);
+EXPORT_SYMBOL_GPL(bt878);
 
-#if defined(__powerpc__)	/* big-endian */
-extern __inline__ void io_st_le32(volatile unsigned *addr, unsigned val)
-{
-	__asm__ __volatile__("stwbrx %1,0,%2":"=m"(*addr):"r"(val),
-			     "r"(addr));
-	__asm__ __volatile__("eieio":::"memory");
-}
-
-#define btwrite(dat,adr)  io_st_le32((unsigned *)(bt->bt878_mem+(adr)),(dat))
-#define btread(adr)       ld_le32((unsigned *)(bt->bt878_mem+(adr)))
-#else
-#define btwrite(dat,adr)    writel((dat), (char *) (bt->bt878_mem+(adr)))
-#define btread(adr)         readl(bt->bt878_mem+(adr))
-#endif
+#define btwrite(dat,adr)    bmtwrite((dat), (bt->bt878_mem+(adr)))
+#define btread(adr)         bmtread(bt->bt878_mem+(adr))
 
 #define btand(dat,adr)      btwrite((dat) & btread(adr), adr)
 #define btor(dat,adr)       btwrite((dat) | btread(adr), adr)
@@ -153,9 +143,6 @@ static int bt878_mem_alloc(struct bt878 *bt)
 
 static int bt878_make_risc(struct bt878 *bt)
 {
-	u32 buf_pos = 0;
-	u32 line;
-
 	bt->block_bytes = bt->buf_size >> 4;
 	bt->block_count = 1 << 4;
 	bt->line_bytes = bt->block_bytes;
@@ -170,11 +157,21 @@ static int bt878_make_risc(struct bt878 *bt)
 		printk("bt878: buffer size error!\n");
 		return -EINVAL;
 	}
+	return 0;
+}
+
+
+static void bt878_risc_program(struct bt878 *bt, u32 op_sync_orin)
+{
+	u32 buf_pos = 0;
+	u32 line;
 
 	RISC_FLUSH();
-	RISC_INSTR(RISC_SYNC | RISC_SYNC_FM1);
+	RISC_INSTR(RISC_SYNC | RISC_SYNC_FM1 | op_sync_orin);
 	RISC_INSTR(0);
 
+	dprintk("bt878: risc len lines %u, bytes per line %u\n", 
+			bt->line_count, bt->line_bytes);
 	for (line = 0; line < bt->line_count; line++) {
 		// At the beginning of every block we issue an IRQ with previous (finished) block number set
 		if (!(buf_pos % bt->block_bytes))
@@ -193,30 +190,50 @@ static int bt878_make_risc(struct bt878 *bt)
 		buf_pos += bt->line_bytes;
 	}
 
-	RISC_INSTR(RISC_SYNC | RISC_SYNC_VRO);
+	RISC_INSTR(RISC_SYNC | op_sync_orin | RISC_SYNC_VRO);
 	RISC_INSTR(0);
 
 	RISC_INSTR(RISC_JUMP);
 	RISC_INSTR(bt->risc_dma);
 
 	btwrite((bt->line_count << 16) | bt->line_bytes, BT878_APACK_LEN);
-	return 0;
 }
 
 /*****************************/
 /* Start/Stop grabbing funcs */
 /*****************************/
 
-void bt878_start(struct bt878 *bt, u32 controlreg)
+void bt878_start(struct bt878 *bt, u32 controlreg, u32 op_sync_orin,
+		u32 irq_err_ignore)
 {
 	dprintk("bt878 debug: bt878_start (ctl=%8.8x)\n", controlreg);
+	u32 int_mask;
 
-	controlreg &= ~0x1F;
+	/* complete the writing of the risc dma program now we have
+	 * the card specifics
+	 */
+	bt878_risc_program(bt, op_sync_orin);
+	controlreg &= ~0x13;
 	controlreg |= 0x1B;
 
 	btwrite(cpu_to_le32(bt->risc_dma), BT878_ARISC_START);
 
-	btwrite(0x000ff800, BT878_AINT_MASK);
+	/* original int mask had :
+	 *    6    2    8    4    0
+	 * 1111 1111 1000 0000 0000
+	 * SCERR|OCERR|PABORT|RIPERR|FDSR|FTRGT|FBUS|RISCI
+	 * Hacked for DST to:
+	 * SCERR | OCERR | FDSR | FTRGT | FBUS | RISCI
+	 */
+	int_mask = BT878_ASCERR | BT878_AOCERR | BT878_APABORT | 
+		BT878_ARIPERR | BT878_APPERR | BT878_AFDSR | BT878_AFTRGT | 
+		BT878_AFBUS | BT878_ARISCI;
+
+
+	/* ignore pesky bits */
+	int_mask &= ~irq_err_ignore;
+	
+	btwrite(int_mask, BT878_AINT_MASK);
 	btwrite(controlreg, BT878_AGPIO_DMA_CTL);
 }
 
@@ -228,7 +245,7 @@ void bt878_stop(struct bt878 *bt)
 	dprintk("bt878 debug: bt878_stop\n");
 
 	btwrite(0, BT878_AINT_MASK);
-	btand(~0x1F, BT878_AGPIO_DMA_CTL);
+	btand(~0x13, BT878_AGPIO_DMA_CTL);
 
 	do {
 		stat = btread(BT878_AINT_STAT);
@@ -241,8 +258,8 @@ void bt878_stop(struct bt878 *bt)
 		bt->nr, i, stat);
 }
 
-EXPORT_SYMBOL(bt878_start);
-EXPORT_SYMBOL(bt878_stop);
+EXPORT_SYMBOL_GPL(bt878_start);
+EXPORT_SYMBOL_GPL(bt878_stop);
 
 /*****************************/
 /* Interrupt service routine */
@@ -430,7 +447,7 @@ static void __devexit bt878_remove(struct pci_dev *pci_dev)
 		printk("bt878(%d): unloading\n", bt->nr);
 
 	/* turn off all capturing, DMA and IRQs */
-	btand(~15, BT878_AGPIO_DMA_CTL);
+	btand(~13, BT878_AGPIO_DMA_CTL);
 
 	/* first disable interrupts before unmapping the memory! */
 	btwrite(0, BT878_AINT_MASK);
@@ -499,6 +516,8 @@ void bt878_cleanup_module(void)
 	return;
 }
 
+EXPORT_SYMBOL_GPL(bt878_init_module);
+EXPORT_SYMBOL_GPL(bt878_cleanup_module);
 module_init(bt878_init_module);
 module_exit(bt878_cleanup_module);
 
diff --git a/linux/drivers/media/dvb/bt8xx/bt878.h b/linux/drivers/media/dvb/bt8xx/bt878.h
index 2f3afc77d..e929a062d 100644
--- a/linux/drivers/media/dvb/bt8xx/bt878.h
+++ b/linux/drivers/media/dvb/bt8xx/bt878.h
@@ -74,7 +74,19 @@
 
 #define BT878_ARISC_PC		0x120
 
+/* BT878 FUNCTION 0 REGISTERS */
+#define BT878_GPIO_DMA_CTL	0x10c
+
+/* Interrupt register */
+#define BT878_INT_STAT		0x100
+#define BT878_INT_MASK		0x104
+#define BT878_I2CRACK		(1<<25)
+#define BT878_I2CDONE		(1<<8)
+
 #define BT878_MAX 4
+
+#define BT878_RISC_SYNC_MASK	(1 << 15)
+
 extern int bt878_num;
 extern struct bt878 bt878[BT878_MAX];
 
@@ -86,7 +98,7 @@ struct bt878 {
 	unsigned char revision;
 	unsigned int irq;
 	unsigned long bt878_adr;
-	unsigned char *bt878_mem;
+	unsigned char *bt878_mem; /* function 1 */
 
 	volatile u32 finished_block;
 	volatile u32 last_block;
@@ -108,6 +120,23 @@ struct bt878 {
 	int shutdown;	
 };
 
-void bt878_start(struct bt878 *bt, u32 controlreg);
+void bt878_start(struct bt878 *bt, u32 controlreg, u32 op_sync_orin,
+		u32 irq_err_ignore);
 void bt878_stop(struct bt878 *bt);	     
+
+#if defined(__powerpc__)	/* big-endian */
+extern __inline__ void io_st_le32(volatile unsigned *addr, unsigned val)
+{
+	__asm__ __volatile__("stwbrx %1,0,%2":"=m"(*addr):"r"(val),
+			     "r"(addr));
+	__asm__ __volatile__("eieio":::"memory");
+}
+
+#define bmtwrite(dat,adr)  io_st_le32((unsigned *)(adr),(dat))
+#define bmtread(adr)       ld_le32((unsigned *)(adr))
+#else
+#define bmtwrite(dat,adr)  writel((dat), (char *) (adr))
+#define bmtread(adr)       readl(adr)
+#endif
+
 #endif
diff --git a/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.c b/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.c
index fdac1634f..3adaddd2c 100644
--- a/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.c
+++ b/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.c
@@ -30,15 +30,31 @@
 #include "dvbdev.h"
 #include "dvb_demux.h"
 #include "dvb_frontend.h"
+#include "dvb_functions.h"
 
 #include "dvb-bt8xx.h"
 #include "bt878.h"
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+#include "dst.h"
+#else
+#include "../frontends/dst.h"
+#endif
+
+
+/* ID THAT MUST GO INTO i2c ids */
+#ifndef  I2C_DRIVERID_DVB_BT878A
+# define I2C_DRIVERID_DVB_BT878A I2C_DRIVERID_EXP0+10
+#endif
+
 
 #define dprintk if (debug) printk
 
 extern int bttv_get_cardinfo(unsigned int card, int *type, int *cardid);
-extern struct i2c_adapter *bttv_get_i2c_adap(unsigned int card);
 extern struct pci_dev* bttv_get_pcidev(unsigned int card);
+extern int bttv_gpio_enable(unsigned int card, unsigned long mask, unsigned long data);
+extern int bttv_read_gpio(unsigned int card, unsigned long *data);
+extern int bttv_write_gpio(unsigned int card, unsigned long mask, unsigned long data);
+
 
 static LIST_HEAD(card_list);
 static int debug = 0;
@@ -50,19 +66,11 @@ static void dvb_bt8xx_task(unsigned long data)
 	//printk("%d ", finished_block);
 
 	while (card->bt->last_block != card->bt->finished_block) {
-		dvb_dmx_swfilter(&card->demux, &card->bt->buf_cpu[card->bt->last_block * card->bt->block_bytes], card->bt->block_bytes);
+		(card->TS_Size ? dvb_dmx_swfilter_204 : dvb_dmx_swfilter)(&card->demux, &card->bt->buf_cpu[card->bt->last_block * card->bt->block_bytes], card->bt->block_bytes);
 		card->bt->last_block = (card->bt->last_block + 1) % card->bt->block_count;
 	}
 }
 
-
-static int dvb_bt8xx_master_xfer(struct dvb_i2c_bus *i2c, const struct i2c_msg msgs[], int num)
-{
-	struct dvb_bt8xx_card *card = (struct dvb_bt8xx_card *)i2c->data;
-
-	return i2c_transfer(card->i2c_adap, msgs, num);
-}
-
 static int dvb_bt8xx_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 {
 	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
@@ -103,71 +111,295 @@ static int dvb_bt8xx_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
 	return 0;
 }
 
-static struct bt878 *dvb_bt8xx_get_bt(unsigned int bttv_nr)
+static int master_xfer (struct dvb_i2c_bus *i2c, const struct i2c_msg msgs[], int num)
+{
+	struct dvb_bt8xx_card *card = i2c->data;
+	int retval;
+	int  i;
+	struct dst_gpio_packet *mp;
+
+	if (down_interruptible (&card->i2c_lock))
+		return -ERESTARTSYS;
+	retval = 0;
+	for (i = 0 ; i < num; i++) {
+		
+		if (msgs[i].addr != DST_IG_ADDR) {
+			retval = i2c_transfer(card->i2c_adapter, &msgs[i], 1);
+			if (retval < 0) {
+				break;
+			}
+			continue;
+		}
+		if (msgs[i].len < sizeof(struct dst_gpio_packet)) {
+			retval = -EINVAL;
+			break;
+		}
+		mp = (struct dst_gpio_packet *)(msgs[i].buf);
+		/* special gpio signal */
+		switch (mp->cmd) {
+		    case DST_IG_ENABLE:
+			// dprintk("dvb_bt8xx: dst enable mask 0x%02x enb 0x%02x \n", mp->dstg.enb.mask, mp->dstg.enb.enable);
+			retval = bttv_gpio_enable(card->bttv_nr,
+					mp->dstg.enb.mask,
+					mp->dstg.enb.enable);
+			if (retval < 0)
+				break;
+			continue;
+		    case DST_IG_WRITE:
+			// dprintk("dvb_bt8xx: dst write gpio mask 0x%02x out 0x%02x\n", mp->dstg.outp.mask, mp->dstg.outp.highvals);
+			retval = bttv_write_gpio(card->bttv_nr,
+					mp->dstg.outp.mask,
+					mp->dstg.outp.highvals);
+
+			if (retval < 0)
+				break;
+			continue;
+		    case DST_IG_READ:
+			/* read */
+			retval =  bttv_read_gpio(card->bttv_nr, &mp->dstg.rd.value);
+			if (retval < 0)
+				break;
+			// dprintk("dvb_bt8xx: dst read gpio 0x%02x\n", (unsigned)mp->dstg.rd.value);
+			continue;
+		    case DST_IG_TS:
+			/* Set packet size */
+			card->TS_Size = 1;
+			continue;
+
+		    default:
+			retval = -EINVAL;
+			break;
+		}
+		break;
+	}
+	up(&card->i2c_lock);
+	if (retval < 0)
+		return retval;
+	if (i < num) {
+		dprintk("%s: i %d less than num %d\n", __FUNCTION__, i, num);
+		return -EIO;
+	}
+	return num;
+}
+
+static int is_pci_slot_eq(struct pci_dev* adev, struct pci_dev* bdev)
+{
+	if ((adev->subsystem_vendor == bdev->subsystem_vendor) &&
+		(adev->subsystem_device == bdev->subsystem_device) &&
+		(adev->bus->number == bdev->bus->number) &&
+		(PCI_SLOT(adev->devfn) == PCI_SLOT(bdev->devfn)))
+		return 1;
+	return 0;
+}
+
+static struct bt878 __init *dvb_bt8xx_878_match(unsigned int bttv_nr, struct pci_dev* bttv_pci_dev)
 {
-	struct pci_dev* bttv_pci_dev;
 	unsigned int card_nr;
 	
-	if (!(bttv_pci_dev = bttv_get_pcidev(bttv_nr)))
-		return NULL;
-	
+	/* Hmm, n squared. Hope n is small */
 	for (card_nr = 0; card_nr < bt878_num; card_nr++) {
-		if ((bt878[card_nr].dev->subsystem_vendor == bttv_pci_dev->subsystem_vendor) &&
-			(bt878[card_nr].dev->subsystem_device == bttv_pci_dev->subsystem_device) &&
-			(bt878[card_nr].dev->bus->number == bttv_pci_dev->bus->number) &&
-			(PCI_SLOT(bt878[card_nr].dev->devfn) == PCI_SLOT(bttv_pci_dev->devfn)))
+		if (is_pci_slot_eq(bt878[card_nr].dev, bttv_pci_dev))
 			return &bt878[card_nr];
 	}
-	
 	return NULL;
 }
 
-static int __init dvb_bt8xx_load(unsigned int bttv_nr, char *card_name, u32 gpio_mode)
+static int __init dvb_bt8xx_card_match(unsigned int bttv_nr, char *card_name, u32 gpio_mode, u32 op_sync_orin, u32 irq_err_ignore)
 {
 	struct dvb_bt8xx_card *card;
-	int result;
+	struct pci_dev* bttv_pci_dev;
 
 	dprintk("dvb_bt8xx: identified card%d as %s\n", bttv_nr, card_name);
 			
 	if (!(card = kmalloc(sizeof(struct dvb_bt8xx_card), GFP_KERNEL)))
 		return -ENOMEM;
 
+	memset(card, 0, sizeof(*card));
 	card->bttv_nr = bttv_nr;
+	strncpy(card->card_name, card_name, sizeof(card_name) - 1);
 	
-	if (!(card->bt = dvb_bt8xx_get_bt(card->bttv_nr))) {
-		printk("dvb_bt8xx: unable to determine DMA core of card%d\n", card->bttv_nr);
+	if (!(bttv_pci_dev = bttv_get_pcidev(bttv_nr))) {
+		printk("dvb_bt8xx: no pci device for card %d\n", card->bttv_nr);
+		kfree(card);
+		return -EFAULT;
+	}
+
+	if (!(card->bt = dvb_bt8xx_878_match(card->bttv_nr, bttv_pci_dev))) {
+		printk("dvb_bt8xx: unable to determine DMA core of card %d\n", card->bttv_nr);
 	
+		kfree(card);
 		return -EFAULT;
 		
 	}
 		
 	card->gpio_mode = gpio_mode;
+	card->op_sync_orin = op_sync_orin;
+	card->irq_err_ignore = irq_err_ignore;
+	list_add_tail(&card->list, &card_list);
+
+	return 0;
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
+/* with 2.6.x not needed thanks to the driver model + sysfs */
+
+extern struct i2c_adapter *bttv_get_i2c_adap(unsigned int card);
+
+static void __init dvb_bt8xx_get_adaps(void)
+{
+	struct dvb_bt8xx_card *card;
+	struct list_head *entry, *entry_safe;
+
+	list_for_each_safe(entry, entry_safe, &card_list) {
+		card = list_entry(entry, struct dvb_bt8xx_card, list);
+		card->i2c_adapter =  bttv_get_i2c_adap(card->bttv_nr);
+		if (!card->i2c_adapter) {
+			printk("dvb_bt8xx: unable to determine i2c adaptor of card %d, deleting\n", card->bttv_nr);
+
+			list_del(&card->list);
+			kfree(card);
+		}
+		init_MUTEX(&card->i2c_lock);
+	}
+}
+
+static void dvb_bt8xx_adap_free(struct i2c_adapter *adap)
+{
+}
+
+static void __exit dvb_bt8xx_exit_adaps(void)
+{
+}
+
+#else
+
+/* More complicated. but cleaner better */
+
+static struct dvb_bt8xx_card *dvb_bt8xx_find_by_adap(struct i2c_adapter *adap)
+{
+	struct dvb_bt8xx_card *card;
+	struct list_head *item;
 	
-	if (!(card->i2c_adap = bttv_get_i2c_adap(card->bttv_nr))) {
-		printk("dvb_bt8xx: unable to determine i2c adapter of card%d\n", card->bttv_nr);
+	printk("find by adap: checking \"%s\"\n",adap->name);
+	list_for_each(item, &card_list) {
+		card = list_entry(item, struct dvb_bt8xx_card, list);
+		if (card->i2c_adapter == adap)
+			return card;
+	}
+	return NULL;
+}
+
+static struct dvb_bt8xx_card *dvb_bt8xx_find_by_pci(struct i2c_adapter *adap)
+{
+	struct dvb_bt8xx_card *card;
+	struct list_head *item;
+	struct device  *dev;
+	struct pci_dev *pci;
+	
+	printk("find by pci: checking \"%s\"\n",adap->name);
+	dev = adap->dev.parent;
+	if (NULL == dev) {
+		/* shoudn't happen with 2.6.0-test7 + newer */
+		printk("attach: Huh? i2c adapter not in sysfs tree?\n");
+		return 0;
+	}
+	pci = to_pci_dev(dev);
+	list_for_each(item, &card_list) {
+		card = list_entry(item, struct dvb_bt8xx_card, list);
+		if (is_pci_slot_eq(pci, card->bt->dev)) {
+			return card;
+		}
+	}
+	return NULL;
+}
+
+static int dvb_bt8xx_attach(struct i2c_adapter *adap)
+{
+	struct dvb_bt8xx_card *card;
+	
+	printk("attach: checking \"%s\"\n",adap->name);
+
+	/* looking for bt878 cards ... */
+	if (adap->id != (I2C_ALGO_BIT | I2C_HW_B_BT848))
+		return 0;
+	card = dvb_bt8xx_find_by_pci(adap);
+	if (!card)
+		return 0;
+	card->i2c_adapter = adap;
+	init_MUTEX(&card->i2c_lock);
+	printk("attach: \"%s\", to card %d\n",
+	       adap->name, card->bttv_nr);
+	try_module_get(adap->owner);
+
+	return 0;
+}
+
+static void dvb_bt8xx_adap_free(struct i2c_adapter *adap)
+{
+	module_put(adap->owner);
+}
+
+static int dvb_bt8xx_detach(struct i2c_adapter *adap)
+{
+	struct dvb_bt8xx_card *card;
+
+	card = dvb_bt8xx_find_by_adap(adap);
+	if (!card)
+		return 0;
+
+	/* This should not happen. We have locked the module! */
+	printk("detach: \"%s\", for card %d removed\n",
+	       adap->name, card->bttv_nr);
+	return 0;
+}
+
+static struct i2c_driver dvb_bt8xx_driver = {
+	.owner           = THIS_MODULE,
+	.name            = "dvb_bt8xx",
+        .id              = I2C_DRIVERID_DVB_BT878A,
+	.flags           = I2C_DF_NOTIFY,
+        .attach_adapter  = dvb_bt8xx_attach,
+        .detach_adapter  = dvb_bt8xx_detach,
+};
+
+static void __init dvb_bt8xx_get_adaps(void)
+{
+	i2c_add_driver(&dvb_bt8xx_driver);
+}
+
+static void __exit dvb_bt8xx_exit_adaps(void)
+{
+	i2c_del_driver(&dvb_bt8xx_driver);
+}
+#endif
+
+static int __init dvb_bt8xx_load_card( struct dvb_bt8xx_card *card)
+{
+	int result;
+
+	if (!card->i2c_adapter) {
+		printk("dvb_bt8xx: unable to determine i2c adaptor of card %d, deleting\n", card->bttv_nr);
 
-		kfree(card);
-		
 		return -EFAULT;
 	
 	}
 
-	if ((result = dvb_register_adapter(&card->adapter, card_name)) < 0) {
+	bttv_gpio_enable(card->bttv_nr, ~0, 0);
+
+	if ((result = dvb_register_adapter(&card->dvb_adapter, card->card_name)) < 0) {
 	
 		printk("dvb_bt8xx: dvb_register_adapter failed (errno = %d)\n", result);
 		
-		kfree(card);
-		
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 		return result;
 		
 	}
 
-	if (!(dvb_register_i2c_bus(dvb_bt8xx_master_xfer, card, card->adapter, 0))) {
+	if (!(dvb_register_i2c_bus(master_xfer, card, card->dvb_adapter, 0))) {
 		printk("dvb_bt8xx: dvb_register_i2c_bus of card%d failed\n", card->bttv_nr);
 
-		dvb_unregister_adapter(card->adapter);
-
-		kfree(card);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 
 		return -EFAULT;
 	}
@@ -186,8 +418,9 @@ static int __init dvb_bt8xx_load(unsigned int bttv_nr, char *card_name, u32 gpio
 	if ((result = dvb_dmx_init(&card->demux)) < 0) {
 		printk("dvb_bt8xx: dvb_dmx_init failed (errno = %d)\n", result);
 
-		dvb_unregister_i2c_bus(dvb_bt8xx_master_xfer, card->adapter, 0);
-		dvb_unregister_adapter(card->adapter);
+		dvb_unregister_i2c_bus(master_xfer, card->dvb_adapter, 0);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 		
 		return result;
 	}
@@ -196,12 +429,13 @@ static int __init dvb_bt8xx_load(unsigned int bttv_nr, char *card_name, u32 gpio
 	card->dmxdev.demux = &card->demux.dmx;
 	card->dmxdev.capabilities = 0;
 	
-	if ((result = dvb_dmxdev_init(&card->dmxdev, card->adapter)) < 0) {
+	if ((result = dvb_dmxdev_init(&card->dmxdev, card->dvb_adapter)) < 0) {
 		printk("dvb_bt8xx: dvb_dmxdev_init failed (errno = %d)\n", result);
 
 		dvb_dmx_release(&card->demux);
-		dvb_unregister_i2c_bus(dvb_bt8xx_master_xfer, card->adapter, 0);
-		dvb_unregister_adapter(card->adapter);
+		dvb_unregister_i2c_bus(master_xfer, card->dvb_adapter, 0);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 		
 		return result;
 	}
@@ -213,8 +447,9 @@ static int __init dvb_bt8xx_load(unsigned int bttv_nr, char *card_name, u32 gpio
 
 		dvb_dmxdev_release(&card->dmxdev);
 		dvb_dmx_release(&card->demux);
-		dvb_unregister_i2c_bus(dvb_bt8xx_master_xfer, card->adapter, 0);
-		dvb_unregister_adapter(card->adapter);
+		dvb_unregister_i2c_bus(master_xfer, card->dvb_adapter, 0);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 		
 		return result;
 	}
@@ -227,8 +462,9 @@ static int __init dvb_bt8xx_load(unsigned int bttv_nr, char *card_name, u32 gpio
 		card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
 		dvb_dmxdev_release(&card->dmxdev);
 		dvb_dmx_release(&card->demux);
-		dvb_unregister_i2c_bus(dvb_bt8xx_master_xfer, card->adapter, 0);
-		dvb_unregister_adapter(card->adapter);
+		dvb_unregister_i2c_bus(master_xfer, card->dvb_adapter, 0);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 		
 		return result;
 	}
@@ -240,49 +476,36 @@ static int __init dvb_bt8xx_load(unsigned int bttv_nr, char *card_name, u32 gpio
 		card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
 		dvb_dmxdev_release(&card->dmxdev);
 		dvb_dmx_release(&card->demux);
-		dvb_unregister_i2c_bus(dvb_bt8xx_master_xfer, card->adapter, 0);
-		dvb_unregister_adapter(card->adapter);
+		dvb_unregister_i2c_bus(master_xfer, card->dvb_adapter, 0);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
 		
 		return result;
 	}
 
-	dvb_net_init(card->adapter, &card->dvbnet, &card->demux.dmx);
+	dvb_net_init(card->dvb_adapter, &card->dvbnet, &card->demux.dmx);
 
 	tasklet_init(&card->bt->tasklet, dvb_bt8xx_task, (unsigned long) card);
 	
-	bt878_start(card->bt, card->gpio_mode);
-
-	list_add_tail(&card->list, &card_list);
+	bt878_start(card->bt, card->gpio_mode, card->op_sync_orin, card->irq_err_ignore);
 
 	return 0;
-
 }
 
-static void dvb_bt8xx_close(void)
+static int __init dvb_bt8xx_load_all(void)
 {
 	struct dvb_bt8xx_card *card;
 	struct list_head *entry, *entry_safe;
 
 	list_for_each_safe(entry, entry_safe, &card_list) {
 		card = list_entry(entry, struct dvb_bt8xx_card, list);
-		
-		dprintk("dvb_bt8xx: unloading card%d\n", card->bttv_nr);
-
-		bt878_stop(card->bt);
-
-		tasklet_kill(&card->bt->tasklet);
-		dvb_net_release(&card->dvbnet);
-		card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_mem);
-		card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
-		dvb_dmxdev_release(&card->dmxdev);
-		dvb_dmx_release(&card->demux);
-		dvb_unregister_i2c_bus(dvb_bt8xx_master_xfer, card->adapter, 0);
-		dvb_unregister_adapter(card->adapter);
-		
-		kfree(card);
-		
-		list_del(&card->list);
+		if (dvb_bt8xx_load_card(card) < 0) {
+			list_del(&card->list);
+			kfree(card);
+			continue;
+		}
 	}
+	return 0;
 
 }
 
@@ -292,21 +515,44 @@ static int __init dvb_bt8xx_init(void)
 	int card_id;
 	int card_type;
 
-	dprintk("dvb_bt8xx: enumerating availible bttv cards...\n");
+	dprintk("dvb_bt8xx: enumerating available bttv cards...\n");
 	
 	while (bttv_get_cardinfo(card_nr, &card_type, &card_id) == 0) {
 		switch(card_id) {
 			case 0x001C11BD:
-				dvb_bt8xx_load(card_nr, "Pinnacle PCTV DVB-S",
-					       0x0400C060);
+				dvb_bt8xx_card_match(card_nr, "Pinnacle PCTV DVB-S",
+					       0x0400C060, 0, 0);
+				/* 26, 15, 14, 6, 5 
+				 * A_G2X  DA_DPM DA_SBR DA_IOM_DA 
+				 * DA_APP(parallel) */
 				break;
 			case 0x01010071:
-				dvb_bt8xx_load(card_nr, "Nebula DigiTV DVB-T",
-					     (1 << 26) | (1 << 14) | (1 << 5));
+				dvb_bt8xx_card_match(card_nr, "Nebula DigiTV DVB-T",
+					     (1 << 26) | (1 << 14) | (1 << 5),
+					     0, 0);
+				/* A_PWRDN DA_SBR DA_APP (high speed serial) */
 				break;
 			case 0x07611461:
-				dvb_bt8xx_load(card_nr, "Avermedia DVB-T",
-					     (1 << 26) | (1 << 14) | (1 << 5));
+				dvb_bt8xx_card_match(card_nr, "Avermedia DVB-T",
+					     (1 << 26) | (1 << 14) | (1 << 5),
+					     0, 0);
+				/* A_PWRDN DA_SBR DA_APP (high speed serial) */
+				break;
+			case 0x0:
+				dvb_bt8xx_card_match(card_nr, "DST DVB-S", 0x2204f2c,
+						BT878_RISC_SYNC_MASK,
+						BT878_APABORT | BT878_ARIPERR | BT878_APPERR | BT878_AFBUS);
+				/* 25,21,14,11,10,9,8,3,2 then
+				 * 0x33 = 5,4,1,0
+				 * A_SEL=SML, DA_MLB, DA_SBR, 
+				 * DA_SDR=f, fifo trigger = 32 DWORDS
+				 * IOM = 0 == audio A/D
+				 * DPM = 0 == digital audio mode
+				 * == async data parallel port
+				 * then 0x33 (13 is set by start_capture)
+				 * DA_APP = async data parallel port, 
+				 * ACAP_EN = 1,
+				 * RISC+FIFO ENABLE */
 				break;
 			default:
 				dprintk("%s: unknown card_nr found %0X\n",
@@ -318,6 +564,8 @@ static int __init dvb_bt8xx_init(void)
 		}
 		card_nr++;
 	}
+	dvb_bt8xx_get_adaps();
+	dvb_bt8xx_load_all();
 
 	return 0;
 
@@ -325,7 +573,32 @@ static int __init dvb_bt8xx_init(void)
 
 static void __exit dvb_bt8xx_exit(void)
 {
-	dvb_bt8xx_close();
+	struct dvb_bt8xx_card *card;
+	struct list_head *entry, *entry_safe;
+
+	dvb_bt8xx_exit_adaps();
+	list_for_each_safe(entry, entry_safe, &card_list) {
+		card = list_entry(entry, struct dvb_bt8xx_card, list);
+		
+		dprintk("dvb_bt8xx: unloading card%d\n", card->bttv_nr);
+
+		bt878_stop(card->bt);
+
+		tasklet_kill(&card->bt->tasklet);
+		dvb_net_release(&card->dvbnet);
+		card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_mem);
+		card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
+		dvb_dmxdev_release(&card->dmxdev);
+		dvb_dmx_release(&card->demux);
+		dvb_unregister_i2c_bus(master_xfer, card->dvb_adapter, 0);
+		dvb_unregister_adapter(card->dvb_adapter);
+		dvb_bt8xx_adap_free(card->i2c_adapter);
+		
+		kfree(card);
+		
+		list_del(&card->list);
+	}
+
 }
 
 module_init(dvb_bt8xx_init);
diff --git a/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.h b/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.h
index acdd8165c..f7e56b181 100644
--- a/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.h
+++ b/linux/drivers/media/dvb/bt8xx/dvb-bt8xx.h
@@ -30,7 +30,9 @@ struct dvb_bt8xx_card {
 
 	struct list_head list;
 	u8 active;
-	struct dvb_adapter *adapter;
+	u8 TS_Size;
+	char card_name[32];
+	struct dvb_adapter *dvb_adapter;
 	struct bt878 *bt;
 	unsigned int bttv_nr;
 	struct dvb_demux demux;
@@ -38,7 +40,10 @@ struct dvb_bt8xx_card {
 	struct dmx_frontend fe_hw;
 	struct dmx_frontend fe_mem;
 	u32 gpio_mode;
-	struct i2c_adapter *i2c_adap;
+	u32 op_sync_orin;
+	u32 irq_err_ignore;
+	struct i2c_adapter *i2c_adapter;
+	struct semaphore      i2c_lock;
 	struct dvb_net dvbnet;
 				
 };