Attachment #53722 for bug #31962





	/* Make sure we can acquire the hardware */
	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
	if (!drv) {
		dprintk(1, "%s: blackbird driver is not loaded\n", __func__);
		mutex_unlock(&dev->core->lock);
		return -ENODEV;
	}

	err = drv->request_acquire(drv);
	if (err != 0) {
		dprintk(1,"%s: Unable to acquire hardware, %d\n", __func__, err);
		mutex_unlock(&dev->core->lock);
		return err;
	}

	if (!dev->core->mpeg_users && blackbird_initialize_codec(dev) < 0) {
		drv->request_release(drv);
			drv->request_release(drv);
		mutex_unlock(&dev->core->lock);
		return -EINVAL;
	}

	/* allocate + initialize per filehandle data */
	fh = kzalloc(sizeof(*fh),GFP_KERNEL);
	if (NULL == fh) {
		drv->request_release(drv);
			drv->request_release(drv);
		mutex_unlock(&dev->core->lock);
		return -ENOMEM;
	}

	cx88_set_scale(dev->core, dev->width, dev->height,
			fh->mpegq.field);

	dev->core->mpeg_users++;
	mutex_unlock(&dev->core->lock);
	return 0;
}

	struct cx8802_dev *dev = fh->dev;
	struct cx8802_driver *drv = NULL;

	mutex_lock(&dev->core->lock);

	if (dev->mpeg_active && dev->core->mpeg_users == 1)
		blackbird_stop_codec(dev);

	cx8802_cancel_buffers(fh->dev);


	videobuf_mmap_free(&fh->mpegq);

	mutex_lock(&dev->core->lock);
	file->private_data = NULL;
	kfree(fh);
	mutex_unlock(&dev->core->lock);

	/* Make sure we release the hardware */
	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
	WARN_ON(!drv);
	if (drv)
		drv->request_release(drv);

	dev->core->mpeg_users--;

	mutex_unlock(&dev->core->lock);

	return 0;
}

	blackbird_register_video(dev);

	/* initial device configuration: needed ? */
	mutex_lock(&dev->core->lock);
//	init_controls(core);
	cx88_set_tvnorm(core,core->tvnorm);
	cx88_video_mux(core,0);
	mutex_unlock(&dev->core->lock);

	return 0;


Lines 133-138 static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire) Link Here

(-)a/drivers/media/video/cx88/cx88-dvb.c (+2 lines)
133	return -EINVAL;	133	return -EINVAL;
134	}	134	}
135		135
		136	mutex_lock(&dev->core->lock);
136	drv = cx8802_get_driver(dev, CX88_MPEG_DVB);	137	drv = cx8802_get_driver(dev, CX88_MPEG_DVB);
137	if (drv) {	138	if (drv) {
138	if (acquire){	139	if (acquire){
Lines 143-148 static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire) Link Here
143	dev->frontends.active_fe_id = 0;	144	dev->frontends.active_fe_id = 0;
144	}	145	}
145	}	146	}
		147	mutex_unlock(&dev->core->lock);
146		148
147	return ret;	149	return ret;
148	}	150	}






static LIST_HEAD(cx8802_devlist);
static DEFINE_MUTEX(cx8802_mutex);
/* ------------------------------------------------------------------ */

static int cx8802_start_dma(struct cx8802_dev    *dev,


	if (drv->advise_acquire)
	{
		mutex_lock(&drv->core->lock);
		core->active_ref++;
		if (core->active_type_id == CX88_BOARD_NONE) {
			core->active_type_id = drv->type_id;
			drv->advise_acquire(drv);
		}
		mutex_unlock(&drv->core->lock);

		mpeg_dbg(1,"%s() Post acquire GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
	}

{
	struct cx88_core *core = drv->core;

	mutex_lock(&drv->core->lock);
	if (drv->advise_release && --core->active_ref == 0)
	{
		drv->advise_release(drv);
		core->active_type_id = CX88_BOARD_NONE;
		mpeg_dbg(1,"%s() Post release GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
	}
	mutex_unlock(&drv->core->lock);

	return 0;
}

		return err;
	}

	mutex_lock(&cx8802_mutex);

	list_for_each_entry(dev, &cx8802_devlist, devlist) {
		printk(KERN_INFO
		       "%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",


		/* Bring up a new struct for each driver instance */
		driver = kzalloc(sizeof(*drv),GFP_KERNEL);
		if (driver == NULL) {
			err = -ENOMEM;
			goto out;
		}

		/* Snapshot of the driver registration data */
		drv->core = dev->core;

		drv->request_release = cx8802_request_release;
		memcpy(driver, drv, sizeof(*driver));

		mutex_lock(&drv->core->lock);
		err = drv->probe(driver);
		if (err == 0) {
			i++;
			mutex_lock(&drv->core->lock);
			list_add_tail(&driver->drvlist, &dev->drvlist);
			mutex_unlock(&drv->core->lock);
		} else {
			printk(KERN_ERR
			       "%s/2: cx8802 probe failed, err = %d\n",
			       dev->core->name, err);
		}
		mutex_unlock(&drv->core->lock);
	}

	err = i ? 0 : -ENODEV;
out:
	mutex_unlock(&cx8802_mutex);
	return err;
}

int cx8802_unregister_driver(struct cx8802_driver *drv)

	       drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird",
	       drv->hw_access == CX8802_DRVCTL_SHARED ? "shared" : "exclusive");

	mutex_lock(&cx8802_mutex);

	list_for_each_entry(dev, &cx8802_devlist, devlist) {
		printk(KERN_INFO
		       "%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",

		       dev->pci->subsystem_device, dev->core->board.name,
		       dev->core->boardnr);

		mutex_lock(&dev->core->lock);

		list_for_each_entry_safe(d, dtmp, &dev->drvlist, drvlist) {
			/* only unregister the correct driver type */
			if (d->type_id != drv->type_id)


			err = d->remove(d);
			if (err == 0) {
				mutex_lock(&drv->core->lock);
				list_del(&d->drvlist);
				mutex_unlock(&drv->core->lock);
				kfree(d);
			} else
				printk(KERN_ERR "%s/2: cx8802 driver remove "
				       "failed (%d)\n", dev->core->name, err);
		}

		mutex_unlock(&dev->core->lock);
	}

	mutex_unlock(&cx8802_mutex);

	return err;
}


		goto fail_free;

	INIT_LIST_HEAD(&dev->drvlist);
	mutex_lock(&cx8802_mutex);
	list_add_tail(&dev->devlist,&cx8802_devlist);
	mutex_unlock(&cx8802_mutex);

	/* now autoload cx88-dvb or cx88-blackbird */
	request_modules(dev);


	flush_request_modules(dev);

	mutex_lock(&dev->core->lock);

	if (!list_empty(&dev->drvlist)) {
		struct cx8802_driver *drv, *tmp;
		int err;

		list_for_each_entry_safe(drv, tmp, &dev->drvlist, drvlist) {
			err = drv->remove(drv);
			if (err == 0) {
				mutex_lock(&drv->core->lock);
				list_del(&drv->drvlist);
				mutex_unlock(&drv->core->lock);
			} else
				printk(KERN_ERR "%s/2: cx8802 driver remove "
				       "failed (%d)\n", dev->core->name, err);

		}
	}

	mutex_unlock(&dev->core->lock);

	/* Destroy any 8802 reference. */
	dev->core->dvbdev = NULL;


Lines 824-830 static int video_open(struct file *file) Link Here

(-)a/drivers/media/video/cx88/cx88-video.c (-2 / +3 lines)
824	call_all(core, tuner, s_radio);	824	call_all(core, tuner, s_radio);
825	}	825	}
826		826
827	atomic_inc(&core->users);	827	core->users++;
828	mutex_unlock(&core->lock);	828	mutex_unlock(&core->lock);
829		829
830	return 0;	830	return 0;
Lines 922-928 static int video_release(struct file *file) Link Here
922	file->private_data = NULL;	922	file->private_data = NULL;
923	kfree(fh);	923	kfree(fh);
924		924
925	if(atomic_dec_and_test(&dev->core->users))	925	dev->core->users--;
		926	if (!dev->core->users)
926	call_all(dev->core, core, s_power, 0);	927	call_all(dev->core, core, s_power, 0);
927	mutex_unlock(&dev->core->lock);	928	mutex_unlock(&dev->core->lock);
928		929

Lines 389-396 struct cx88_core { Link Here

(-)a/drivers/media/video/cx88/cx88.h (-3 / +8 lines)
389	struct mutex lock;	389	struct mutex lock;
390	/* various v4l controls */	390	/* various v4l controls */
391	u32 freq;	391	u32 freq;
392	atomic_t users;	392	int users;
393	atomic_t mpeg_users;	393	int mpeg_users;
394		394
395	/* cx88-video needs to access cx8802 for hybrid tuner pll access. */	395	/* cx88-video needs to access cx8802 for hybrid tuner pll access. */
396	struct cx8802_dev *dvbdev;	396	struct cx8802_dev *dvbdev;
Lines 505-510 struct cx8802_driver { Link Here
505	int (suspend)(struct pci_dev pci_dev, pm_message_t state);	505	int (suspend)(struct pci_dev pci_dev, pm_message_t state);
506	int (resume)(struct pci_dev pci_dev);	506	int (resume)(struct pci_dev pci_dev);
507		507
		508	/* Callers to the following functions must hold core->lock */
		509
508	/* MPEG 8802 -> mini driver - Driver probe and configuration */	510	/* MPEG 8802 -> mini driver - Driver probe and configuration */
509	int (probe)(struct cx8802_driver drv);	511	int (probe)(struct cx8802_driver drv);
510	int (remove)(struct cx8802_driver drv);	512	int (remove)(struct cx8802_driver drv);
Lines 561-568 struct cx8802_dev { Link Here
561	/* for switching modulation types */	563	/* for switching modulation types */
562	unsigned char ts_gen_cntrl;	564	unsigned char ts_gen_cntrl;
563		565
564	/* List of attached drivers */	566	/* List of attached drivers; must hold core->lock to access */
565	struct list_head drvlist;	567	struct list_head drvlist;
		568
566	struct work_struct request_module_wk;	569	struct work_struct request_module_wk;
567	};	570	};
568		571
Lines 685-690 int cx88_audio_thread(void *data); Link Here
685		688
686	int cx8802_register_driver(struct cx8802_driver *drv);	689	int cx8802_register_driver(struct cx8802_driver *drv);
687	int cx8802_unregister_driver(struct cx8802_driver *drv);	690	int cx8802_unregister_driver(struct cx8802_driver *drv);
		691
		692	/* Caller must hold core->lock */
688	struct cx8802_driver * cx8802_get_driver(struct cx8802_dev *dev, enum cx88_board_type btype);	693	struct cx8802_driver * cx8802_get_driver(struct cx8802_dev *dev, enum cx88_board_type btype);
689		694
690	/* ----------------------------------------------------------- */	695	/* ----------------------------------------------------------- */

Return to bug 31962

Lines 1060-1077 static int mpeg_open(struct file *file) Link Here

(-)a/drivers/media/video/cx88/cx88-blackbird.c (-19 / +22 lines)
1060		1060
1061	/* Make sure we can acquire the hardware */	1061	/* Make sure we can acquire the hardware */
1062	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);	1062	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
1063	if (drv) {	1063	if (!drv) {
1064	err = drv->request_acquire(drv);	1064	dprintk(1, "%s: blackbird driver is not loaded\n", __func__);
1065	if(err != 0) {	1065	mutex_unlock(&dev->core->lock);
1066	dprintk(1,"%s: Unable to acquire hardware, %d\n", __func__, err);	1066	return -ENODEV;
1067	mutex_unlock(&dev->core->lock);	1067	}
1068	return err;	1068
1069	}	1069	err = drv->request_acquire(drv);
		1070	if (err != 0) {
		1071	dprintk(1,"%s: Unable to acquire hardware, %d\n", __func__, err);
		1072	mutex_unlock(&dev->core->lock);
		1073	return err;
1070	}	1074	}
1071		1075
1072	if (!atomic_read(&dev->core->mpeg_users) && blackbird_initialize_codec(dev) < 0) {	1076	if (!dev->core->mpeg_users && blackbird_initialize_codec(dev) < 0) {
1073	if (drv)	1077	drv->request_release(drv);
1074	drv->request_release(drv);
1075	mutex_unlock(&dev->core->lock);	1078	mutex_unlock(&dev->core->lock);
1076	return -EINVAL;	1079	return -EINVAL;
1077	}	1080	}
Lines 1080-1087 static int mpeg_open(struct file *file) Link Here
1080	/* allocate + initialize per filehandle data */	1083	/* allocate + initialize per filehandle data */
1081	fh = kzalloc(sizeof(*fh),GFP_KERNEL);	1084	fh = kzalloc(sizeof(*fh),GFP_KERNEL);
1082	if (NULL == fh) {	1085	if (NULL == fh) {
1083	if (drv)	1086	drv->request_release(drv);
1084	drv->request_release(drv);
1085	mutex_unlock(&dev->core->lock);	1087	mutex_unlock(&dev->core->lock);
1086	return -ENOMEM;	1088	return -ENOMEM;
1087	}	1089	}
Lines 1099-1105 static int mpeg_open(struct file *file) Link Here
1099	cx88_set_scale(dev->core, dev->width, dev->height,	1101	cx88_set_scale(dev->core, dev->width, dev->height,
1100	fh->mpegq.field);	1102	fh->mpegq.field);
1101		1103
1102	atomic_inc(&dev->core->mpeg_users);	1104	dev->core->mpeg_users++;
1103	mutex_unlock(&dev->core->lock);	1105	mutex_unlock(&dev->core->lock);
1104	return 0;	1106	return 0;
1105	}	1107	}
Lines 1110-1116 static int mpeg_release(struct file *file) Link Here
1110	struct cx8802_dev *dev = fh->dev;	1112	struct cx8802_dev *dev = fh->dev;
1111	struct cx8802_driver *drv = NULL;	1113	struct cx8802_driver *drv = NULL;
1112		1114
1113	if (dev->mpeg_active && atomic_read(&dev->core->mpeg_users) == 1)	1115	mutex_lock(&dev->core->lock);
		1116
		1117	if (dev->mpeg_active && dev->core->mpeg_users == 1)
1114	blackbird_stop_codec(dev);	1118	blackbird_stop_codec(dev);
1115		1119
1116	cx8802_cancel_buffers(fh->dev);	1120	cx8802_cancel_buffers(fh->dev);
Lines 1119-1135 static int mpeg_release(struct file *file) Link Here
1119		1123
1120	videobuf_mmap_free(&fh->mpegq);	1124	videobuf_mmap_free(&fh->mpegq);
1121		1125
1122	mutex_lock(&dev->core->lock);
1123	file->private_data = NULL;	1126	file->private_data = NULL;
1124	kfree(fh);	1127	kfree(fh);
1125	mutex_unlock(&dev->core->lock);
1126		1128
1127	/* Make sure we release the hardware */	1129	/* Make sure we release the hardware */
1128	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);	1130	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
		1131	WARN_ON(!drv);
1129	if (drv)	1132	if (drv)
1130	drv->request_release(drv);	1133	drv->request_release(drv);
1131		1134
1132	atomic_dec(&dev->core->mpeg_users);	1135	dev->core->mpeg_users--;
		1136
		1137	mutex_unlock(&dev->core->lock);
1133		1138
1134	return 0;	1139	return 0;
1135	}	1140	}
Lines 1334-1344 static int cx8802_blackbird_probe(struct cx8802_driver *drv) Link Here
1334	blackbird_register_video(dev);	1339	blackbird_register_video(dev);
1335		1340
1336	/* initial device configuration: needed ? */	1341	/* initial device configuration: needed ? */
1337	mutex_lock(&dev->core->lock);
1338	// init_controls(core);	1342	// init_controls(core);
1339	cx88_set_tvnorm(core,core->tvnorm);	1343	cx88_set_tvnorm(core,core->tvnorm);
1340	cx88_video_mux(core,0);	1344	cx88_video_mux(core,0);
1341	mutex_unlock(&dev->core->lock);
1342		1345
1343	return 0;	1346	return 0;
1344		1347

Lines 78-83 static void flush_request_modules(struct cx8802_dev *dev) Link Here

(-)a/drivers/media/video/cx88/cx88-mpeg.c (-14 / +26 lines)
78		78
79		79
80	static LIST_HEAD(cx8802_devlist);	80	static LIST_HEAD(cx8802_devlist);
		81	static DEFINE_MUTEX(cx8802_mutex);
81	/* ------------------------------------------------------------------ */	82	/* ------------------------------------------------------------------ */
82		83
83	static int cx8802_start_dma(struct cx8802_dev *dev,	84	static int cx8802_start_dma(struct cx8802_dev *dev,
Lines 624-636 static int cx8802_request_acquire(struct cx8802_driver *drv) Link Here
624		625
625	if (drv->advise_acquire)	626	if (drv->advise_acquire)
626	{	627	{
627	mutex_lock(&drv->core->lock);
628	core->active_ref++;	628	core->active_ref++;
629	if (core->active_type_id == CX88_BOARD_NONE) {	629	if (core->active_type_id == CX88_BOARD_NONE) {
630	core->active_type_id = drv->type_id;	630	core->active_type_id = drv->type_id;
631	drv->advise_acquire(drv);	631	drv->advise_acquire(drv);
632	}	632	}
633	mutex_unlock(&drv->core->lock);
634		633
635	mpeg_dbg(1,"%s() Post acquire GPIO=%x\n", __func__, cx_read(MO_GP0_IO));	634	mpeg_dbg(1,"%s() Post acquire GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
636	}	635	}
Lines 643-656 static int cx8802_request_release(struct cx8802_driver *drv) Link Here
643	{	642	{
644	struct cx88_core *core = drv->core;	643	struct cx88_core *core = drv->core;
645		644
646	mutex_lock(&drv->core->lock);
647	if (drv->advise_release && --core->active_ref == 0)	645	if (drv->advise_release && --core->active_ref == 0)
648	{	646	{
649	drv->advise_release(drv);	647	drv->advise_release(drv);
650	core->active_type_id = CX88_BOARD_NONE;	648	core->active_type_id = CX88_BOARD_NONE;
651	mpeg_dbg(1,"%s() Post release GPIO=%x\n", __func__, cx_read(MO_GP0_IO));	649	mpeg_dbg(1,"%s() Post release GPIO=%x\n", __func__, cx_read(MO_GP0_IO));
652	}	650	}
653	mutex_unlock(&drv->core->lock);
654		651
655	return 0;	652	return 0;
656	}	653	}
Lines 693-698 int cx8802_register_driver(struct cx8802_driver *drv) Link Here
693	return err;	690	return err;
694	}	691	}
695		692
		693	mutex_lock(&cx8802_mutex);
		694
696	list_for_each_entry(dev, &cx8802_devlist, devlist) {	695	list_for_each_entry(dev, &cx8802_devlist, devlist) {
697	printk(KERN_INFO	696	printk(KERN_INFO
698	"%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",	697	"%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",
Lines 702-709 int cx8802_register_driver(struct cx8802_driver *drv) Link Here
702		701
703	/* Bring up a new struct for each driver instance */	702	/* Bring up a new struct for each driver instance */
704	driver = kzalloc(sizeof(*drv),GFP_KERNEL);	703	driver = kzalloc(sizeof(*drv),GFP_KERNEL);
705	if (driver == NULL)	704	if (driver == NULL) {
706	return -ENOMEM;	705	err = -ENOMEM;
		706	goto out;
		707	}
707		708
708	/* Snapshot of the driver registration data */	709	/* Snapshot of the driver registration data */
709	drv->core = dev->core;	710	drv->core = dev->core;
Lines 713-733 int cx8802_register_driver(struct cx8802_driver *drv) Link Here
713	drv->request_release = cx8802_request_release;	714	drv->request_release = cx8802_request_release;
714	memcpy(driver, drv, sizeof(*driver));	715	memcpy(driver, drv, sizeof(*driver));
715		716
		717	mutex_lock(&drv->core->lock);
716	err = drv->probe(driver);	718	err = drv->probe(driver);
717	if (err == 0) {	719	if (err == 0) {
718	i++;	720	i++;
719	mutex_lock(&drv->core->lock);
720	list_add_tail(&driver->drvlist, &dev->drvlist);	721	list_add_tail(&driver->drvlist, &dev->drvlist);
721	mutex_unlock(&drv->core->lock);
722	} else {	722	} else {
723	printk(KERN_ERR	723	printk(KERN_ERR
724	"%s/2: cx8802 probe failed, err = %d\n",	724	"%s/2: cx8802 probe failed, err = %d\n",
725	dev->core->name, err);	725	dev->core->name, err);
726	}	726	}
727		727	mutex_unlock(&drv->core->lock);
728	}	728	}
729		729
730	return i ? 0 : -ENODEV;	730	err = i ? 0 : -ENODEV;
		731	out:
		732	mutex_unlock(&cx8802_mutex);
		733	return err;
731	}	734	}
732		735
733	int cx8802_unregister_driver(struct cx8802_driver *drv)	736	int cx8802_unregister_driver(struct cx8802_driver *drv)
Lines 741-746 int cx8802_unregister_driver(struct cx8802_driver *drv) Link Here
741	drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird",	744	drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird",
742	drv->hw_access == CX8802_DRVCTL_SHARED ? "shared" : "exclusive");	745	drv->hw_access == CX8802_DRVCTL_SHARED ? "shared" : "exclusive");
743		746
		747	mutex_lock(&cx8802_mutex);
		748
744	list_for_each_entry(dev, &cx8802_devlist, devlist) {	749	list_for_each_entry(dev, &cx8802_devlist, devlist) {
745	printk(KERN_INFO	750	printk(KERN_INFO
746	"%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",	751	"%s/2: subsystem: %04x:%04x, board: %s [card=%d]\n",
Lines 748-753 int cx8802_unregister_driver(struct cx8802_driver *drv) Link Here
748	dev->pci->subsystem_device, dev->core->board.name,	753	dev->pci->subsystem_device, dev->core->board.name,
749	dev->core->boardnr);	754	dev->core->boardnr);
750		755
		756	mutex_lock(&dev->core->lock);
		757
751	list_for_each_entry_safe(d, dtmp, &dev->drvlist, drvlist) {	758	list_for_each_entry_safe(d, dtmp, &dev->drvlist, drvlist) {
752	/* only unregister the correct driver type */	759	/* only unregister the correct driver type */
753	if (d->type_id != drv->type_id)	760	if (d->type_id != drv->type_id)
Lines 755-771 int cx8802_unregister_driver(struct cx8802_driver *drv) Link Here
755		762
756	err = d->remove(d);	763	err = d->remove(d);
757	if (err == 0) {	764	if (err == 0) {
758	mutex_lock(&drv->core->lock);
759	list_del(&d->drvlist);	765	list_del(&d->drvlist);
760	mutex_unlock(&drv->core->lock);
761	kfree(d);	766	kfree(d);
762	} else	767	} else
763	printk(KERN_ERR "%s/2: cx8802 driver remove "	768	printk(KERN_ERR "%s/2: cx8802 driver remove "
764	"failed (%d)\n", dev->core->name, err);	769	"failed (%d)\n", dev->core->name, err);
765	}	770	}
766		771
		772	mutex_unlock(&dev->core->lock);
767	}	773	}
768		774
		775	mutex_unlock(&cx8802_mutex);
		776
769	return err;	777	return err;
770	}	778	}
771		779
Lines 803-809 static int __devinit cx8802_probe(struct pci_dev *pci_dev, Link Here
803	goto fail_free;	811	goto fail_free;
804		812
805	INIT_LIST_HEAD(&dev->drvlist);	813	INIT_LIST_HEAD(&dev->drvlist);
		814	mutex_lock(&cx8802_mutex);
806	list_add_tail(&dev->devlist,&cx8802_devlist);	815	list_add_tail(&dev->devlist,&cx8802_devlist);
		816	mutex_unlock(&cx8802_mutex);
807		817
808	/* now autoload cx88-dvb or cx88-blackbird */	818	/* now autoload cx88-dvb or cx88-blackbird */
809	request_modules(dev);	819	request_modules(dev);
Lines 827-832 static void __devexit cx8802_remove(struct pci_dev *pci_dev) Link Here
827		837
828	flush_request_modules(dev);	838	flush_request_modules(dev);
829		839
		840	mutex_lock(&dev->core->lock);
		841
830	if (!list_empty(&dev->drvlist)) {	842	if (!list_empty(&dev->drvlist)) {
831	struct cx8802_driver drv, tmp;	843	struct cx8802_driver drv, tmp;
832	int err;	844	int err;
Lines 838-846 static void __devexit cx8802_remove(struct pci_dev *pci_dev) Link Here
838	list_for_each_entry_safe(drv, tmp, &dev->drvlist, drvlist) {	850	list_for_each_entry_safe(drv, tmp, &dev->drvlist, drvlist) {
839	err = drv->remove(drv);	851	err = drv->remove(drv);
840	if (err == 0) {	852	if (err == 0) {
841	mutex_lock(&drv->core->lock);
842	list_del(&drv->drvlist);	853	list_del(&drv->drvlist);
843	mutex_unlock(&drv->core->lock);
844	} else	854	} else
845	printk(KERN_ERR "%s/2: cx8802 driver remove "	855	printk(KERN_ERR "%s/2: cx8802 driver remove "
846	"failed (%d)\n", dev->core->name, err);	856	"failed (%d)\n", dev->core->name, err);
Lines 848-853 static void __devexit cx8802_remove(struct pci_dev *pci_dev) Link Here
848	}	858	}
849	}	859	}
850		860
		861	mutex_unlock(&dev->core->lock);
		862
851	/* Destroy any 8802 reference. */	863	/* Destroy any 8802 reference. */
852	dev->core->dvbdev = NULL;	864	dev->core->dvbdev = NULL;
853		865