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.

1 files changed, 350 insertions, 77 deletions

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);