V4L/DVB: dm1105: use dm1105_dev & dev instead of dm1105dvb (34d2f9bf) · Commits · EulixOS / Software / Kernel

drivers/media/dvb/dm1105/dm1105.c

+178 −179

Original line number	Original line	Diff line number	Diff line
	@@ -270,7 +270,7 @@ struct infrared {
	u32 ir_command;		u32 ir_command;
	};		};

	struct dm1105dvb {		struct dm1105_dev {
	/* pci */		/* pci */
	struct pci_dev *pdev;		struct pci_dev *pdev;
	u8 __iomem *io_mem;		u8 __iomem *io_mem;
	@@ -309,17 +309,17 @@ struct dm1105dvb {
	spinlock_t lock;		spinlock_t lock;
	};		};

	#define dm_io_mem(reg) ((unsigned long)(&dm1105dvb->io_mem[reg]))		#define dm_io_mem(reg) ((unsigned long)(&dev->io_mem[reg]))

	static int dm1105_i2c_xfer(struct i2c_adapter *i2c_adap,		static int dm1105_i2c_xfer(struct i2c_adapter *i2c_adap,
	struct i2c_msg *msgs, int num)		struct i2c_msg *msgs, int num)
	{		{
	struct dm1105dvb *dm1105dvb ;		struct dm1105_dev *dev ;

	int addr, rc, i, j, k, len, byte, data;		int addr, rc, i, j, k, len, byte, data;
	u8 status;		u8 status;

	dm1105dvb = i2c_adap->algo_data;		dev = i2c_adap->algo_data;
	for (i = 0; i < num; i++) {		for (i = 0; i < num; i++) {
	outb(0x00, dm_io_mem(DM1105_I2CCTR));		outb(0x00, dm_io_mem(DM1105_I2CCTR));
	if (msgs[i].flags & I2C_M_RD) {		if (msgs[i].flags & I2C_M_RD) {
	@@ -406,22 +406,22 @@ static struct i2c_algorithm dm1105_algo = {
	.functionality = functionality,		.functionality = functionality,
	};		};

	static inline struct dm1105dvb feed_to_dm1105dvb(struct dvb_demux_feed feed)		static inline struct dm1105_dev feed_to_dm1105_dev(struct dvb_demux_feed feed)
	{		{
	return container_of(feed->demux, struct dm1105dvb, demux);		return container_of(feed->demux, struct dm1105_dev, demux);
	}		}

	static inline struct dm1105dvb frontend_to_dm1105dvb(struct dvb_frontend fe)		static inline struct dm1105_dev frontend_to_dm1105_dev(struct dvb_frontend fe)
	{		{
	return container_of(fe->dvb, struct dm1105dvb, dvb_adapter);		return container_of(fe->dvb, struct dm1105_dev, dvb_adapter);
	}		}

	static int dm1105dvb_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)		static int dm1105_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
	{		{
	struct dm1105dvb *dm1105dvb = frontend_to_dm1105dvb(fe);		struct dm1105_dev *dev = frontend_to_dm1105_dev(fe);
	u32 lnb_mask, lnb_13v, lnb_18v, lnb_off;		u32 lnb_mask, lnb_13v, lnb_18v, lnb_off;

	switch (dm1105dvb->boardnr) {		switch (dev->boardnr) {
	case DM1105_BOARD_AXESS_DM05:		case DM1105_BOARD_AXESS_DM05:
	lnb_mask = DM05_LNB_MASK;		lnb_mask = DM05_LNB_MASK;
	lnb_off = DM05_LNB_OFF;		lnb_off = DM05_LNB_OFF;
	@@ -448,51 +448,56 @@ static int dm1105dvb_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t volta
	return 0;		return 0;
	}		}

	static void dm1105dvb_set_dma_addr(struct dm1105dvb *dm1105dvb)		static void dm1105_set_dma_addr(struct dm1105_dev *dev)
	{		{
	outl(cpu_to_le32(dm1105dvb->dma_addr), dm_io_mem(DM1105_STADR));		outl(cpu_to_le32(dev->dma_addr), dm_io_mem(DM1105_STADR));
	}		}

	static int __devinit dm1105dvb_dma_map(struct dm1105dvb *dm1105dvb)		static int __devinit dm1105_dma_map(struct dm1105_dev *dev)
	{		{
	dm1105dvb->ts_buf = pci_alloc_consistent(dm1105dvb->pdev, 6*DM1105_DMA_BYTES, &dm1105dvb->dma_addr);		dev->ts_buf = pci_alloc_consistent(dev->pdev,
			6 * DM1105_DMA_BYTES,
			&dev->dma_addr);

	return !dm1105dvb->ts_buf;		return !dev->ts_buf;
	}		}

	static void dm1105dvb_dma_unmap(struct dm1105dvb *dm1105dvb)		static void dm1105_dma_unmap(struct dm1105_dev *dev)
	{		{
	pci_free_consistent(dm1105dvb->pdev, 6*DM1105_DMA_BYTES, dm1105dvb->ts_buf, dm1105dvb->dma_addr);		pci_free_consistent(dev->pdev,
			6 * DM1105_DMA_BYTES,
			dev->ts_buf,
			dev->dma_addr);
	}		}

	static void dm1105dvb_enable_irqs(struct dm1105dvb *dm1105dvb)		static void dm1105_enable_irqs(struct dm1105_dev *dev)
	{		{
	outb(INTMAK_ALLMASK, dm_io_mem(DM1105_INTMAK));		outb(INTMAK_ALLMASK, dm_io_mem(DM1105_INTMAK));
	outb(1, dm_io_mem(DM1105_CR));		outb(1, dm_io_mem(DM1105_CR));
	}		}

	static void dm1105dvb_disable_irqs(struct dm1105dvb *dm1105dvb)		static void dm1105_disable_irqs(struct dm1105_dev *dev)
	{		{
	outb(INTMAK_IRM, dm_io_mem(DM1105_INTMAK));		outb(INTMAK_IRM, dm_io_mem(DM1105_INTMAK));
	outb(0, dm_io_mem(DM1105_CR));		outb(0, dm_io_mem(DM1105_CR));
	}		}

	static int dm1105dvb_start_feed(struct dvb_demux_feed *f)		static int dm1105_start_feed(struct dvb_demux_feed *f)
	{		{
	struct dm1105dvb *dm1105dvb = feed_to_dm1105dvb(f);		struct dm1105_dev *dev = feed_to_dm1105_dev(f);

	if (dm1105dvb->full_ts_users++ == 0)		if (dev->full_ts_users++ == 0)
	dm1105dvb_enable_irqs(dm1105dvb);		dm1105_enable_irqs(dev);

	return 0;		return 0;
	}		}

	static int dm1105dvb_stop_feed(struct dvb_demux_feed *f)		static int dm1105_stop_feed(struct dvb_demux_feed *f)
	{		{
	struct dm1105dvb *dm1105dvb = feed_to_dm1105dvb(f);		struct dm1105_dev *dev = feed_to_dm1105_dev(f);

	if (--dm1105dvb->full_ts_users == 0)		if (--dev->full_ts_users == 0)
	dm1105dvb_disable_irqs(dm1105dvb);		dm1105_disable_irqs(dev);

	return 0;		return 0;
	}		}
	@@ -516,42 +521,39 @@ static void dm1105_emit_key(struct work_struct *work)
	/* work handler */		/* work handler */
	static void dm1105_dmx_buffer(struct work_struct *work)		static void dm1105_dmx_buffer(struct work_struct *work)
	{		{
	struct dm1105dvb *dm1105dvb =		struct dm1105_dev *dev = container_of(work, struct dm1105_dev, work);
	container_of(work, struct dm1105dvb, work);
	unsigned int nbpackets;		unsigned int nbpackets;
	u32 oldwrp = dm1105dvb->wrp;		u32 oldwrp = dev->wrp;
	u32 nextwrp = dm1105dvb->nextwrp;		u32 nextwrp = dev->nextwrp;

	if (!((dm1105dvb->ts_buf[oldwrp] == 0x47) &&		if (!((dev->ts_buf[oldwrp] == 0x47) &&
	(dm1105dvb->ts_buf[oldwrp + 188] == 0x47) &&		(dev->ts_buf[oldwrp + 188] == 0x47) &&
	(dm1105dvb->ts_buf[oldwrp + 188 * 2] == 0x47))) {		(dev->ts_buf[oldwrp + 188 * 2] == 0x47))) {
	dm1105dvb->PacketErrorCount++;		dev->PacketErrorCount++;
	/* bad packet found */		/* bad packet found */
	if ((dm1105dvb->PacketErrorCount >= 2) &&		if ((dev->PacketErrorCount >= 2) &&
	(dm1105dvb->dmarst == 0)) {		(dev->dmarst == 0)) {
	outb(1, dm_io_mem(DM1105_RST));		outb(1, dm_io_mem(DM1105_RST));
	dm1105dvb->wrp = 0;		dev->wrp = 0;
	dm1105dvb->PacketErrorCount = 0;		dev->PacketErrorCount = 0;
	dm1105dvb->dmarst = 0;		dev->dmarst = 0;
	return;		return;
	}		}
	}		}

	if (nextwrp < oldwrp) {		if (nextwrp < oldwrp) {
	memcpy(dm1105dvb->ts_buf + dm1105dvb->buffer_size,		memcpy(dev->ts_buf + dev->buffer_size, dev->ts_buf, nextwrp);
	dm1105dvb->ts_buf, nextwrp);		nbpackets = ((dev->buffer_size - oldwrp) + nextwrp) / 188;
	nbpackets = ((dm1105dvb->buffer_size - oldwrp) + nextwrp) / 188;
	} else		} else
	nbpackets = (nextwrp - oldwrp) / 188;		nbpackets = (nextwrp - oldwrp) / 188;

	dm1105dvb->wrp = nextwrp;		dev->wrp = nextwrp;
	dvb_dmx_swfilter_packets(&dm1105dvb->demux,		dvb_dmx_swfilter_packets(&dev->demux, &dev->ts_buf[oldwrp], nbpackets);
	&dm1105dvb->ts_buf[oldwrp], nbpackets);
	}		}

	static irqreturn_t dm1105dvb_irq(int irq, void *dev_id)		static irqreturn_t dm1105_irq(int irq, void *dev_id)
	{		{
	struct dm1105dvb *dm1105dvb = dev_id;		struct dm1105_dev *dev = dev_id;

	/* Read-Write INSTS Ack's Interrupt for DM1105 chip 16.03.2008 */		/* Read-Write INSTS Ack's Interrupt for DM1105 chip 16.03.2008 */
	unsigned int intsts = inb(dm_io_mem(DM1105_INTSTS));		unsigned int intsts = inb(dm_io_mem(DM1105_INTSTS));
	@@ -560,20 +562,20 @@ static irqreturn_t dm1105dvb_irq(int irq, void *dev_id)
	switch (intsts) {		switch (intsts) {
	case INTSTS_TSIRQ:		case INTSTS_TSIRQ:
	case (INTSTS_TSIRQ \| INTSTS_IR):		case (INTSTS_TSIRQ \| INTSTS_IR):
	dm1105dvb->nextwrp = inl(dm_io_mem(DM1105_WRP)) -		dev->nextwrp = inl(dm_io_mem(DM1105_WRP)) -
	inl(dm_io_mem(DM1105_STADR));		inl(dm_io_mem(DM1105_STADR));
	queue_work(dm1105dvb->wq, &dm1105dvb->work);		queue_work(dev->wq, &dev->work);
	break;		break;
	case INTSTS_IR:		case INTSTS_IR:
	dm1105dvb->ir.ir_command = inl(dm_io_mem(DM1105_IRCODE));		dev->ir.ir_command = inl(dm_io_mem(DM1105_IRCODE));
	schedule_work(&dm1105dvb->ir.work);		schedule_work(&dev->ir.work);
	break;		break;
	}		}

	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}

	int __devinit dm1105_ir_init(struct dm1105dvb *dm1105)		int __devinit dm1105_ir_init(struct dm1105_dev *dm1105)
	{		{
	struct input_dev *input_dev;		struct input_dev *input_dev;
	struct ir_scancode_table *ir_codes = &ir_codes_dm1105_nec_table;		struct ir_scancode_table *ir_codes = &ir_codes_dm1105_nec_table;
	@@ -615,14 +617,14 @@ int __devinit dm1105_ir_init(struct dm1105dvb *dm1105)
	return err;		return err;
	}		}

	void __devexit dm1105_ir_exit(struct dm1105dvb *dm1105)		void __devexit dm1105_ir_exit(struct dm1105_dev *dm1105)
	{		{
	ir_input_unregister(dm1105->ir.input_dev);		ir_input_unregister(dm1105->ir.input_dev);
	}		}

	static int __devinit dm1105dvb_hw_init(struct dm1105dvb *dm1105dvb)		static int __devinit dm1105_hw_init(struct dm1105_dev *dev)
	{		{
	dm1105dvb_disable_irqs(dm1105dvb);		dm1105_disable_irqs(dev);

	outb(0, dm_io_mem(DM1105_HOST_CTR));		outb(0, dm_io_mem(DM1105_HOST_CTR));

	@@ -632,8 +634,8 @@ static int __devinit dm1105dvb_hw_init(struct dm1105dvb *dm1105dvb)
	outw(0xc10a, dm_io_mem(DM1105_TSCTR));		outw(0xc10a, dm_io_mem(DM1105_TSCTR));

	/* map DMA and set address */		/* map DMA and set address */
	dm1105dvb_dma_map(dm1105dvb);		dm1105_dma_map(dev);
	dm1105dvb_set_dma_addr(dm1105dvb);		dm1105_set_dma_addr(dev);
	/* big buffer */		/* big buffer */
	outl(5*DM1105_DMA_BYTES, dm_io_mem(DM1105_RLEN));		outl(5*DM1105_DMA_BYTES, dm_io_mem(DM1105_RLEN));
	outb(47, dm_io_mem(DM1105_INTCNT));		outb(47, dm_io_mem(DM1105_INTCNT));
	@@ -646,15 +648,15 @@ static int __devinit dm1105dvb_hw_init(struct dm1105dvb *dm1105dvb)
	return 0;		return 0;
	}		}

	static void dm1105dvb_hw_exit(struct dm1105dvb *dm1105dvb)		static void dm1105_hw_exit(struct dm1105_dev *dev)
	{		{
	dm1105dvb_disable_irqs(dm1105dvb);		dm1105_disable_irqs(dev);

	/* IR disable */		/* IR disable */
	outb(0, dm_io_mem(DM1105_IRCTR));		outb(0, dm_io_mem(DM1105_IRCTR));
	outb(INTMAK_NONEMASK, dm_io_mem(DM1105_INTMAK));		outb(INTMAK_NONEMASK, dm_io_mem(DM1105_INTMAK));

	dm1105dvb_dma_unmap(dm1105dvb);		dm1105_dma_unmap(dev);
	}		}

	static struct stv0299_config sharp_z0194a_config = {		static struct stv0299_config sharp_z0194a_config = {
	@@ -688,78 +690,75 @@ static struct ds3000_config dvbworld_ds3000_config = {
	.demod_address = 0x68,		.demod_address = 0x68,
	};		};

	static int __devinit frontend_init(struct dm1105dvb *dm1105dvb)		static int __devinit frontend_init(struct dm1105_dev *dev)
	{		{
	int ret;		int ret;

	switch (dm1105dvb->boardnr) {		switch (dev->boardnr) {
	case DM1105_BOARD_DVBWORLD_2004:		case DM1105_BOARD_DVBWORLD_2004:
	dm1105dvb->fe = dvb_attach(		dev->fe = dvb_attach(
	cx24116_attach, &serit_sp2633_config,		cx24116_attach, &serit_sp2633_config,
	&dm1105dvb->i2c_adap);		&dev->i2c_adap);
	if (dm1105dvb->fe) {		if (dev->fe) {
	dm1105dvb->fe->ops.set_voltage = dm1105dvb_set_voltage;		dev->fe->ops.set_voltage = dm1105_set_voltage;
	break;		break;
	}		}

	dm1105dvb->fe = dvb_attach(		dev->fe = dvb_attach(
	ds3000_attach, &dvbworld_ds3000_config,		ds3000_attach, &dvbworld_ds3000_config,
	&dm1105dvb->i2c_adap);		&dev->i2c_adap);
	if (dm1105dvb->fe)		if (dev->fe)
	dm1105dvb->fe->ops.set_voltage = dm1105dvb_set_voltage;		dev->fe->ops.set_voltage = dm1105_set_voltage;

	break;		break;
	case DM1105_BOARD_DVBWORLD_2002:		case DM1105_BOARD_DVBWORLD_2002:
	case DM1105_BOARD_AXESS_DM05:		case DM1105_BOARD_AXESS_DM05:
	default:		default:
	dm1105dvb->fe = dvb_attach(		dev->fe = dvb_attach(
	stv0299_attach, &sharp_z0194a_config,		stv0299_attach, &sharp_z0194a_config,
	&dm1105dvb->i2c_adap);		&dev->i2c_adap);
	if (dm1105dvb->fe) {		if (dev->fe) {
	dm1105dvb->fe->ops.set_voltage =		dev->fe->ops.set_voltage = dm1105_set_voltage;
	dm1105dvb_set_voltage;		dvb_attach(dvb_pll_attach, dev->fe, 0x60,
	dvb_attach(dvb_pll_attach, dm1105dvb->fe, 0x60,		&dev->i2c_adap, DVB_PLL_OPERA1);
	&dm1105dvb->i2c_adap, DVB_PLL_OPERA1);
	break;		break;
	}		}

	dm1105dvb->fe = dvb_attach(		dev->fe = dvb_attach(
	stv0288_attach, &earda_config,		stv0288_attach, &earda_config,
	&dm1105dvb->i2c_adap);		&dev->i2c_adap);
	if (dm1105dvb->fe) {		if (dev->fe) {
	dm1105dvb->fe->ops.set_voltage =		dev->fe->ops.set_voltage = dm1105_set_voltage;
	dm1105dvb_set_voltage;		dvb_attach(stb6000_attach, dev->fe, 0x61,
	dvb_attach(stb6000_attach, dm1105dvb->fe, 0x61,		&dev->i2c_adap);
	&dm1105dvb->i2c_adap);
	break;		break;
	}		}

	dm1105dvb->fe = dvb_attach(		dev->fe = dvb_attach(
	si21xx_attach, &serit_config,		si21xx_attach, &serit_config,
	&dm1105dvb->i2c_adap);		&dev->i2c_adap);
	if (dm1105dvb->fe)		if (dev->fe)
	dm1105dvb->fe->ops.set_voltage =		dev->fe->ops.set_voltage = dm1105_set_voltage;
	dm1105dvb_set_voltage;

	}		}

	if (!dm1105dvb->fe) {		if (!dev->fe) {
	dev_err(&dm1105dvb->pdev->dev, "could not attach frontend\n");		dev_err(&dev->pdev->dev, "could not attach frontend\n");
	return -ENODEV;		return -ENODEV;
	}		}

	ret = dvb_register_frontend(&dm1105dvb->dvb_adapter, dm1105dvb->fe);		ret = dvb_register_frontend(&dev->dvb_adapter, dev->fe);
	if (ret < 0) {		if (ret < 0) {
	if (dm1105dvb->fe->ops.release)		if (dev->fe->ops.release)
	dm1105dvb->fe->ops.release(dm1105dvb->fe);		dev->fe->ops.release(dev->fe);
	dm1105dvb->fe = NULL;		dev->fe = NULL;
	return ret;		return ret;
	}		}

	return 0;		return 0;
	}		}

	static void __devinit dm1105dvb_read_mac(struct dm1105dvb dm1105dvb, u8 mac)		static void __devinit dm1105_read_mac(struct dm1105_dev dev, u8 mac)
	{		{
	static u8 command[1] = { 0x28 };		static u8 command[1] = { 0x28 };

	@@ -777,47 +776,47 @@ static void __devinit dm1105dvb_read_mac(struct dm1105dvb dm1105dvb, u8 mac)
	},		},
	};		};

	dm1105_i2c_xfer(&dm1105dvb->i2c_adap, msg , 2);		dm1105_i2c_xfer(&dev->i2c_adap, msg , 2);
	dev_info(&dm1105dvb->pdev->dev, "MAC %pM\n", mac);		dev_info(&dev->pdev->dev, "MAC %pM\n", mac);
	}		}

	static int __devinit dm1105_probe(struct pci_dev *pdev,		static int __devinit dm1105_probe(struct pci_dev *pdev,
	const struct pci_device_id *ent)		const struct pci_device_id *ent)
	{		{
	struct dm1105dvb *dm1105dvb;		struct dm1105_dev *dev;
	struct dvb_adapter *dvb_adapter;		struct dvb_adapter *dvb_adapter;
	struct dvb_demux *dvbdemux;		struct dvb_demux *dvbdemux;
	struct dmx_demux *dmx;		struct dmx_demux *dmx;
	int ret = -ENOMEM;		int ret = -ENOMEM;
	int i;		int i;

	dm1105dvb = kzalloc(sizeof(struct dm1105dvb), GFP_KERNEL);		dev = kzalloc(sizeof(struct dm1105_dev), GFP_KERNEL);
	if (!dm1105dvb)		if (!dev)
	return -ENOMEM;		return -ENOMEM;

	/* board config */		/* board config */
	dm1105dvb->nr = dm1105_devcount;		dev->nr = dm1105_devcount;
	dm1105dvb->boardnr = UNSET;		dev->boardnr = UNSET;
	if (card[dm1105dvb->nr] < ARRAY_SIZE(dm1105_boards))		if (card[dev->nr] < ARRAY_SIZE(dm1105_boards))
	dm1105dvb->boardnr = card[dm1105dvb->nr];		dev->boardnr = card[dev->nr];
	for (i = 0; UNSET == dm1105dvb->boardnr &&		for (i = 0; UNSET == dev->boardnr &&
	i < ARRAY_SIZE(dm1105_subids); i++)		i < ARRAY_SIZE(dm1105_subids); i++)
	if (pdev->subsystem_vendor ==		if (pdev->subsystem_vendor ==
	dm1105_subids[i].subvendor &&		dm1105_subids[i].subvendor &&
	pdev->subsystem_device ==		pdev->subsystem_device ==
	dm1105_subids[i].subdevice)		dm1105_subids[i].subdevice)
	dm1105dvb->boardnr = dm1105_subids[i].card;		dev->boardnr = dm1105_subids[i].card;

	if (UNSET == dm1105dvb->boardnr) {		if (UNSET == dev->boardnr) {
	dm1105dvb->boardnr = DM1105_BOARD_UNKNOWN;		dev->boardnr = DM1105_BOARD_UNKNOWN;
	dm1105_card_list(pdev);		dm1105_card_list(pdev);
	}		}

	dm1105_devcount++;		dm1105_devcount++;
	dm1105dvb->pdev = pdev;		dev->pdev = pdev;
	dm1105dvb->buffer_size = 5 * DM1105_DMA_BYTES;		dev->buffer_size = 5 * DM1105_DMA_BYTES;
	dm1105dvb->PacketErrorCount = 0;		dev->PacketErrorCount = 0;
	dm1105dvb->dmarst = 0;		dev->dmarst = 0;

	ret = pci_enable_device(pdev);		ret = pci_enable_device(pdev);
	if (ret < 0)		if (ret < 0)
	@@ -833,47 +832,47 @@ static int __devinit dm1105_probe(struct pci_dev *pdev,
	if (ret < 0)		if (ret < 0)
	goto err_pci_disable_device;		goto err_pci_disable_device;

	dm1105dvb->io_mem = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));		dev->io_mem = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
	if (!dm1105dvb->io_mem) {		if (!dev->io_mem) {
	ret = -EIO;		ret = -EIO;
	goto err_pci_release_regions;		goto err_pci_release_regions;
	}		}

	spin_lock_init(&dm1105dvb->lock);		spin_lock_init(&dev->lock);
	pci_set_drvdata(pdev, dm1105dvb);		pci_set_drvdata(pdev, dev);

	ret = dm1105dvb_hw_init(dm1105dvb);		ret = dm1105_hw_init(dev);
	if (ret < 0)		if (ret < 0)
	goto err_pci_iounmap;		goto err_pci_iounmap;

	/* i2c */		/* i2c */
	i2c_set_adapdata(&dm1105dvb->i2c_adap, dm1105dvb);		i2c_set_adapdata(&dev->i2c_adap, dev);
	strcpy(dm1105dvb->i2c_adap.name, DRIVER_NAME);		strcpy(dev->i2c_adap.name, DRIVER_NAME);
	dm1105dvb->i2c_adap.owner = THIS_MODULE;		dev->i2c_adap.owner = THIS_MODULE;
	dm1105dvb->i2c_adap.class = I2C_CLASS_TV_DIGITAL;		dev->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
	dm1105dvb->i2c_adap.dev.parent = &pdev->dev;		dev->i2c_adap.dev.parent = &pdev->dev;
	dm1105dvb->i2c_adap.algo = &dm1105_algo;		dev->i2c_adap.algo = &dm1105_algo;
	dm1105dvb->i2c_adap.algo_data = dm1105dvb;		dev->i2c_adap.algo_data = dev;
	ret = i2c_add_adapter(&dm1105dvb->i2c_adap);		ret = i2c_add_adapter(&dev->i2c_adap);

	if (ret < 0)		if (ret < 0)
	goto err_dm1105dvb_hw_exit;		goto err_dm1105_hw_exit;

	/* dvb */		/* dvb */
	ret = dvb_register_adapter(&dm1105dvb->dvb_adapter, DRIVER_NAME,		ret = dvb_register_adapter(&dev->dvb_adapter, DRIVER_NAME,
	THIS_MODULE, &pdev->dev, adapter_nr);		THIS_MODULE, &pdev->dev, adapter_nr);
	if (ret < 0)		if (ret < 0)
	goto err_i2c_del_adapter;		goto err_i2c_del_adapter;

	dvb_adapter = &dm1105dvb->dvb_adapter;		dvb_adapter = &dev->dvb_adapter;

	dm1105dvb_read_mac(dm1105dvb, dvb_adapter->proposed_mac);		dm1105_read_mac(dev, dvb_adapter->proposed_mac);

	dvbdemux = &dm1105dvb->demux;		dvbdemux = &dev->demux;
	dvbdemux->filternum = 256;		dvbdemux->filternum = 256;
	dvbdemux->feednum = 256;		dvbdemux->feednum = 256;
	dvbdemux->start_feed = dm1105dvb_start_feed;		dvbdemux->start_feed = dm1105_start_feed;
	dvbdemux->stop_feed = dm1105dvb_stop_feed;		dvbdemux->stop_feed = dm1105_stop_feed;
	dvbdemux->dmx.capabilities = (DMX_TS_FILTERING \|		dvbdemux->dmx.capabilities = (DMX_TS_FILTERING \|
	DMX_SECTION_FILTERING \| DMX_MEMORY_BASED_FILTERING);		DMX_SECTION_FILTERING \| DMX_MEMORY_BASED_FILTERING);
	ret = dvb_dmx_init(dvbdemux);		ret = dvb_dmx_init(dvbdemux);
	@@ -881,113 +880,113 @@ static int __devinit dm1105_probe(struct pci_dev *pdev,
	goto err_dvb_unregister_adapter;		goto err_dvb_unregister_adapter;

	dmx = &dvbdemux->dmx;		dmx = &dvbdemux->dmx;
	dm1105dvb->dmxdev.filternum = 256;		dev->dmxdev.filternum = 256;
	dm1105dvb->dmxdev.demux = dmx;		dev->dmxdev.demux = dmx;
	dm1105dvb->dmxdev.capabilities = 0;		dev->dmxdev.capabilities = 0;

	ret = dvb_dmxdev_init(&dm1105dvb->dmxdev, dvb_adapter);		ret = dvb_dmxdev_init(&dev->dmxdev, dvb_adapter);
	if (ret < 0)		if (ret < 0)
	goto err_dvb_dmx_release;		goto err_dvb_dmx_release;

	dm1105dvb->hw_frontend.source = DMX_FRONTEND_0;		dev->hw_frontend.source = DMX_FRONTEND_0;

	ret = dmx->add_frontend(dmx, &dm1105dvb->hw_frontend);		ret = dmx->add_frontend(dmx, &dev->hw_frontend);
	if (ret < 0)		if (ret < 0)
	goto err_dvb_dmxdev_release;		goto err_dvb_dmxdev_release;

	dm1105dvb->mem_frontend.source = DMX_MEMORY_FE;		dev->mem_frontend.source = DMX_MEMORY_FE;

	ret = dmx->add_frontend(dmx, &dm1105dvb->mem_frontend);		ret = dmx->add_frontend(dmx, &dev->mem_frontend);
	if (ret < 0)		if (ret < 0)
	goto err_remove_hw_frontend;		goto err_remove_hw_frontend;

	ret = dmx->connect_frontend(dmx, &dm1105dvb->hw_frontend);		ret = dmx->connect_frontend(dmx, &dev->hw_frontend);
	if (ret < 0)		if (ret < 0)
	goto err_remove_mem_frontend;		goto err_remove_mem_frontend;

	ret = frontend_init(dm1105dvb);		ret = frontend_init(dev);
	if (ret < 0)		if (ret < 0)
	goto err_disconnect_frontend;		goto err_disconnect_frontend;

	dvb_net_init(dvb_adapter, &dm1105dvb->dvbnet, dmx);		dvb_net_init(dvb_adapter, &dev->dvbnet, dmx);
	dm1105_ir_init(dm1105dvb);		dm1105_ir_init(dev);

	INIT_WORK(&dm1105dvb->work, dm1105_dmx_buffer);		INIT_WORK(&dev->work, dm1105_dmx_buffer);
	sprintf(dm1105dvb->wqn, "%s/%d", dvb_adapter->name, dvb_adapter->num);		sprintf(dev->wqn, "%s/%d", dvb_adapter->name, dvb_adapter->num);
	dm1105dvb->wq = create_singlethread_workqueue(dm1105dvb->wqn);		dev->wq = create_singlethread_workqueue(dev->wqn);
	if (!dm1105dvb->wq)		if (!dev->wq)
	goto err_dvb_net;		goto err_dvb_net;

	ret = request_irq(pdev->irq, dm1105dvb_irq, IRQF_SHARED,		ret = request_irq(pdev->irq, dm1105_irq, IRQF_SHARED,
	DRIVER_NAME, dm1105dvb);		DRIVER_NAME, dev);
	if (ret < 0)		if (ret < 0)
	goto err_workqueue;		goto err_workqueue;

	return 0;		return 0;

	err_workqueue:		err_workqueue:
	destroy_workqueue(dm1105dvb->wq);		destroy_workqueue(dev->wq);
	err_dvb_net:		err_dvb_net:
	dvb_net_release(&dm1105dvb->dvbnet);		dvb_net_release(&dev->dvbnet);
	err_disconnect_frontend:		err_disconnect_frontend:
	dmx->disconnect_frontend(dmx);		dmx->disconnect_frontend(dmx);
	err_remove_mem_frontend:		err_remove_mem_frontend:
	dmx->remove_frontend(dmx, &dm1105dvb->mem_frontend);		dmx->remove_frontend(dmx, &dev->mem_frontend);
	err_remove_hw_frontend:		err_remove_hw_frontend:
	dmx->remove_frontend(dmx, &dm1105dvb->hw_frontend);		dmx->remove_frontend(dmx, &dev->hw_frontend);
	err_dvb_dmxdev_release:		err_dvb_dmxdev_release:
	dvb_dmxdev_release(&dm1105dvb->dmxdev);		dvb_dmxdev_release(&dev->dmxdev);
	err_dvb_dmx_release:		err_dvb_dmx_release:
	dvb_dmx_release(dvbdemux);		dvb_dmx_release(dvbdemux);
	err_dvb_unregister_adapter:		err_dvb_unregister_adapter:
	dvb_unregister_adapter(dvb_adapter);		dvb_unregister_adapter(dvb_adapter);
	err_i2c_del_adapter:		err_i2c_del_adapter:
	i2c_del_adapter(&dm1105dvb->i2c_adap);		i2c_del_adapter(&dev->i2c_adap);
	err_dm1105dvb_hw_exit:		err_dm1105_hw_exit:
	dm1105dvb_hw_exit(dm1105dvb);		dm1105_hw_exit(dev);
	err_pci_iounmap:		err_pci_iounmap:
	pci_iounmap(pdev, dm1105dvb->io_mem);		pci_iounmap(pdev, dev->io_mem);
	err_pci_release_regions:		err_pci_release_regions:
	pci_release_regions(pdev);		pci_release_regions(pdev);
	err_pci_disable_device:		err_pci_disable_device:
	pci_disable_device(pdev);		pci_disable_device(pdev);
	err_kfree:		err_kfree:
	pci_set_drvdata(pdev, NULL);		pci_set_drvdata(pdev, NULL);
	kfree(dm1105dvb);		kfree(dev);
	return ret;		return ret;
	}		}

	static void __devexit dm1105_remove(struct pci_dev *pdev)		static void __devexit dm1105_remove(struct pci_dev *pdev)
	{		{
	struct dm1105dvb *dm1105dvb = pci_get_drvdata(pdev);		struct dm1105_dev *dev = pci_get_drvdata(pdev);
	struct dvb_adapter *dvb_adapter = &dm1105dvb->dvb_adapter;		struct dvb_adapter *dvb_adapter = &dev->dvb_adapter;
	struct dvb_demux *dvbdemux = &dm1105dvb->demux;		struct dvb_demux *dvbdemux = &dev->demux;
	struct dmx_demux *dmx = &dvbdemux->dmx;		struct dmx_demux *dmx = &dvbdemux->dmx;

	dm1105_ir_exit(dm1105dvb);		dm1105_ir_exit(dev);
	dmx->close(dmx);		dmx->close(dmx);
	dvb_net_release(&dm1105dvb->dvbnet);		dvb_net_release(&dev->dvbnet);
	if (dm1105dvb->fe)		if (dev->fe)
	dvb_unregister_frontend(dm1105dvb->fe);		dvb_unregister_frontend(dev->fe);

	dmx->disconnect_frontend(dmx);		dmx->disconnect_frontend(dmx);
	dmx->remove_frontend(dmx, &dm1105dvb->mem_frontend);		dmx->remove_frontend(dmx, &dev->mem_frontend);
	dmx->remove_frontend(dmx, &dm1105dvb->hw_frontend);		dmx->remove_frontend(dmx, &dev->hw_frontend);
	dvb_dmxdev_release(&dm1105dvb->dmxdev);		dvb_dmxdev_release(&dev->dmxdev);
	dvb_dmx_release(dvbdemux);		dvb_dmx_release(dvbdemux);
	dvb_unregister_adapter(dvb_adapter);		dvb_unregister_adapter(dvb_adapter);
	if (&dm1105dvb->i2c_adap)		if (&dev->i2c_adap)
	i2c_del_adapter(&dm1105dvb->i2c_adap);		i2c_del_adapter(&dev->i2c_adap);

	dm1105dvb_hw_exit(dm1105dvb);		dm1105_hw_exit(dev);
	synchronize_irq(pdev->irq);		synchronize_irq(pdev->irq);
	free_irq(pdev->irq, dm1105dvb);		free_irq(pdev->irq, dev);
	pci_iounmap(pdev, dm1105dvb->io_mem);		pci_iounmap(pdev, dev->io_mem);
	pci_release_regions(pdev);		pci_release_regions(pdev);
	pci_disable_device(pdev);		pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);		pci_set_drvdata(pdev, NULL);
	dm1105_devcount--;		dm1105_devcount--;
	kfree(dm1105dvb);		kfree(dev);
	}		}

	static struct pci_device_id dm1105_id_table[] __devinitdata = {		static struct pci_device_id dm1105_id_table[] __devinitdata = {