Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 66aa66ea authored by Trent Piepho's avatar Trent Piepho Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (10212): Convert to be a pci driver 



This is a really old and crufty driver that wasn't using the long
established pci driver framework.

Signed-off-by: default avatarTrent Piepho <xyzzy@speakeasy.org>
Acked-by: default avatarJean Delvare <khali@linux-fr.org>
[mchehab@redhat.com: Cleaned up a few CodingStyle issues]
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent f90c3c0b

drivers/media/video/zoran/zoran_card.c

+294 −302
Original line number Diff line number Diff line
@@ -153,16 +153,13 @@ MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver"); 
MODULE_AUTHOR("Serguei Miridonov");

MODULE_LICENSE("GPL");



#if (defined(CONFIG_VIDEO_ZORAN_MODULE) && defined(MODULE))

static struct pci_device_id zr36067_pci_tbl[] = {

	{PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057,

	 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},

	{ PCI_DEVICE(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057), },

	{0}

};

MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);

#endif



int zoran_num;			/* number of Buzs in use */

atomic_t zoran_num = ATOMIC_INIT(0);		/* number of Buzs in use */

struct zoran *zoran[BUZ_MAX];



/* videocodec bus functions ZR36060 */
@@ -1146,7 +1143,7 @@ zr36057_init (struct zoran *zr) 
	strcpy(zr->video_dev->name, ZR_DEVNAME(zr));

	err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);

	if (err < 0)

		goto exit_unregister;

		goto exit_free;



	zoran_init_hardware(zr);

	if (zr36067_debug > 2)
@@ -1161,19 +1158,19 @@ zr36057_init (struct zoran *zr) 
	zr->initialized = 1;

	return 0;



exit_unregister:

	zoran_unregister_i2c(zr);

exit_free:

	kfree(zr->stat_com);

	kfree(zr->video_dev);

	return err;

}



static void

zoran_release (struct zoran *zr)

static void __devexit zoran_remove(struct pci_dev *pdev)

{

	struct zoran *zr = pci_get_drvdata(pdev);



	if (!zr->initialized)

		goto exit_free;



	/* unregister videocodec bus */

	if (zr->codec) {

		struct videocodec_master *master = zr->codec->master_data;
@@ -1202,6 +1199,7 @@ zoran_release (struct zoran *zr) 
	pci_disable_device(zr->pci_dev);

	video_unregister_device(zr->video_dev);

exit_free:

	pci_set_drvdata(pdev, NULL);

	kfree(zr);

}
@@ -1264,41 +1262,47 @@ zoran_setup_videocodec (struct zoran *zr, 
 *   Scan for a Buz card (actually for the PCI controller ZR36057),

 *   request the irq and map the io memory

 */

static int __devinit

find_zr36057 (void)

static int __devinit zoran_probe(struct pci_dev *pdev,

				 const struct pci_device_id *ent)

{

	unsigned char latency, need_latency;

	struct zoran *zr;

	struct pci_dev *dev = NULL;

	int result;

	struct videocodec_master *master_vfe = NULL;

	struct videocodec_master *master_codec = NULL;

	int card_num;

	char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;

	unsigned int nr;



	zoran_num = 0;

	while (zoran_num < BUZ_MAX &&

	       (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {

		card_num = card[zoran_num];



	nr = atomic_inc_return(&zoran_num) - 1;

	if (nr >= BUZ_MAX) {

		dprintk(1,

			KERN_ERR

			"%s: driver limited to %d card(s) maximum\n",

			ZORAN_NAME, BUZ_MAX);

		return -ENOENT;

	}



	card_num = card[nr];

	zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);

	if (!zr) {

		dprintk(1,

			KERN_ERR

			"%s: find_zr36057() - kzalloc failed\n",

			ZORAN_NAME);

			continue;

		/* The entry in zoran[] gets leaked */

		return -ENOMEM;

	}

		zr->pci_dev = dev;

		//zr->zr36057_mem = NULL;

		zr->id = zoran_num;

	zr->pci_dev = pdev;

	zr->id = nr;

	snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);

	spin_lock_init(&zr->spinlock);

	mutex_init(&zr->resource_lock);

		if (pci_enable_device(dev))

	if (pci_enable_device(pdev))

		goto zr_free_mem;

	zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);

		pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,

				     &zr->revision);

	pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION, &zr->revision);

	if (zr->revision < 2) {

		dprintk(1,

			KERN_INFO
@@ -1381,11 +1385,8 @@ find_zr36057 (void) 
		goto zr_free_mem;

	}



		result = request_irq(zr->pci_dev->irq,

				     zoran_irq,

				     IRQF_SHARED | IRQF_DISABLED,

				     ZR_DEVNAME(zr),

				     (void *) zr);

	result = request_irq(zr->pci_dev->irq, zoran_irq,

			     IRQF_SHARED | IRQF_DISABLED, ZR_DEVNAME(zr), zr);

	if (result < 0) {

		if (result == -EINVAL) {

			dprintk(1,
@@ -1413,10 +1414,9 @@ find_zr36057 (void) 
	if (latency != need_latency) {

		dprintk(2,

			KERN_INFO

				"%s: Changing PCI latency from %d to %d.\n",

			"%s: Changing PCI latency from %d to %d\n",

			ZR_DEVNAME(zr), latency, need_latency);

			pci_write_config_byte(zr->pci_dev,

					      PCI_LATENCY_TIMER,

		pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,

				      need_latency);

	}
@@ -1430,14 +1430,14 @@ find_zr36057 (void) 
		i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);

		zr->card.i2c_decoder = decoder[zr->id];

	} else if (zr->card.i2c_decoder != 0) {

			i2c_dec_name =

				i2cid_to_modulename(zr->card.i2c_decoder);

		i2c_dec_name = i2cid_to_modulename(zr->card.i2c_decoder);

	} else {

		i2c_dec_name = NULL;

	}



	if (i2c_dec_name) {

			if ((result = request_module(i2c_dec_name)) < 0) {

		result = request_module(i2c_dec_name);

		if (result < 0) {

			dprintk(1,

				KERN_ERR

				"%s: failed to load module %s: %d\n",
@@ -1450,14 +1450,14 @@ find_zr36057 (void) 
		i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);

		zr->card.i2c_encoder = encoder[zr->id];

	} else if (zr->card.i2c_encoder != 0) {

			i2c_enc_name =

				i2cid_to_modulename(zr->card.i2c_encoder);

		i2c_enc_name = i2cid_to_modulename(zr->card.i2c_encoder);

	} else {

		i2c_enc_name = NULL;

	}



	if (i2c_enc_name) {

			if ((result = request_module(i2c_enc_name)) < 0) {

		result = request_module(i2c_enc_name);

		if (result < 0) {

			dprintk(1,

				KERN_ERR

				"%s: failed to load module %s: %d\n",
@@ -1477,26 +1477,30 @@ find_zr36057 (void) 
		KERN_INFO "%s: Initializing videocodec bus...\n",

		ZR_DEVNAME(zr));



		if (zr->card.video_codec != 0 &&

		    (codec_name =

		     codecid_to_modulename(zr->card.video_codec)) != NULL) {

			if ((result = request_module(codec_name)) < 0) {

	if (zr->card.video_codec) {

		codec_name = codecid_to_modulename(zr->card.video_codec);

		if (codec_name) {

			result = request_module(codec_name);

			if (result) {

				dprintk(1,

					KERN_ERR

					"%s: failed to load modules %s: %d\n",

					ZR_DEVNAME(zr), codec_name, result);

			}

		}

		if (zr->card.video_vfe != 0 &&

		    (vfe_name =

		     codecid_to_modulename(zr->card.video_vfe)) != NULL) {

			if ((result = request_module(vfe_name)) < 0) {

	}

	if (zr->card.video_vfe) {

		vfe_name = codecid_to_modulename(zr->card.video_vfe);

		if (vfe_name) {

			result = request_module(vfe_name);

			if (result < 0) {

				dprintk(1,

					KERN_ERR

					"%s: failed to load modules %s: %d\n",

					ZR_DEVNAME(zr), vfe_name, result);

			}

		}

	}



	/* reset JPEG codec */

	jpeg_codec_sleep(zr, 1);
@@ -1504,8 +1508,7 @@ find_zr36057 (void) 
	/* video bus enabled */

	/* display codec revision */

	if (zr->card.video_codec != 0) {

			master_codec = zoran_setup_videocodec(zr,

							      zr->card.video_codec);

		master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);

		if (!master_codec)

			goto zr_unreg_i2c;

		zr->codec = videocodec_attach(master_codec);
@@ -1525,8 +1528,7 @@ find_zr36057 (void) 
		}

	}

	if (zr->card.video_vfe != 0) {

			master_vfe = zoran_setup_videocodec(zr,

							    zr->card.video_vfe);

		master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);

		if (!master_vfe)

			goto zr_detach_codec;

		zr->vfe = videocodec_attach(master_vfe);
@@ -1545,12 +1547,26 @@ find_zr36057 (void) 
			goto zr_detach_vfe;

		}

	}

		/* Success so keep the pci_dev referenced */

		pci_dev_get(zr->pci_dev);

		zoran[zoran_num++] = zr;

		continue;

	zoran[nr] = zr;



	/* take care of Natoma chipset and a revision 1 zr36057 */

	if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {

		zr->jpg_buffers.need_contiguous = 1;

		dprintk(1,

			KERN_INFO

			"%s: ZR36057/Natoma bug, max. buffer size is 128K\n",

			ZR_DEVNAME(zr));

	}



	if (zr36057_init(zr) < 0)

		goto zr_detach_vfe;



	zoran_proc_init(zr);



	pci_set_drvdata(pdev, zr);



	return 0;



		// Init errors

zr_detach_vfe:

	videocodec_detach(zr->vfe);

zr_free_vfe:
@@ -1568,34 +1584,25 @@ find_zr36057 (void) 
	iounmap(zr->zr36057_mem);

zr_free_mem:

	kfree(zr);

		continue;

	}

	if (dev)	/* Clean up ref count on early exit */

		pci_dev_put(dev);



	if (zoran_num == 0) {

		dprintk(1, KERN_INFO "No known MJPEG cards found.\n");

	}

	return zoran_num;

	return -ENODEV;

}



static int __init

init_dc10_cards (void)

static struct pci_driver zoran_driver = {

	.name = "zr36067",

	.id_table = zr36067_pci_tbl,

	.probe = zoran_probe,

	.remove = zoran_remove,

};



static int __init zoran_init(void)

{

	int i;

	int res;



	memset(zoran, 0, sizeof(zoran));

	printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",

	       MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);



	/* Look for cards */

	if (find_zr36057() < 0) {

		return -EIO;

	}

	if (zoran_num == 0)

		return -ENODEV;

	dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,

		zoran_num);

	/* check the parameters we have been given, adjust if necessary */

	if (v4l_nbufs < 2)

		v4l_nbufs = 2;
@@ -1637,37 +1644,22 @@ init_dc10_cards (void) 
			ZORAN_NAME);

	}



	/* take care of Natoma chipset and a revision 1 zr36057 */

	for (i = 0; i < zoran_num; i++) {

		struct zoran *zr = zoran[i];



		if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {

			zr->jpg_buffers.need_contiguous = 1;

	res = pci_register_driver(&zoran_driver);

	if (res) {

		dprintk(1,

				KERN_INFO

				"%s: ZR36057/Natoma bug, max. buffer size is 128K\n",

				ZR_DEVNAME(zr));

		}



		if (zr36057_init(zr) < 0) {

			for (i = 0; i < zoran_num; i++)

				zoran_release(zoran[i]);

			return -EIO;

		}

		zoran_proc_init(zr);

			KERN_ERR

			"%s: Unable to register ZR36057 driver\n",

			ZORAN_NAME);

		return res;

	}



	return 0;

}



static void __exit

unload_dc10_cards (void)

static void __exit zoran_exit(void)

{

	int i;



	for (i = 0; i < zoran_num; i++)

		zoran_release(zoran[i]);

	pci_unregister_driver(&zoran_driver);

}



module_init(init_dc10_cards);

module_exit(unload_dc10_cards);
 
module_init(zoran_init);

module_exit(zoran_exit);

drivers/media/video/zoran/zoran_card.h

+1 −1
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ extern int zr36067_debug; 


/* Anybody who uses more than four? */

#define BUZ_MAX 4

extern int zoran_num;

extern atomic_t zoran_num;

extern struct zoran *zoran[BUZ_MAX];



extern struct video_device zoran_template;

drivers/media/video/zoran/zoran_driver.c

+1 −1
Original line number Diff line number Diff line
@@ -1206,7 +1206,7 @@ zoran_open(struct file *file) 


	lock_kernel();

	/* find the device */

	for (i = 0; i < zoran_num; i++) {

	for (i = 0; i < atomic_read(&zoran_num); i++) {

		if (zoran[i]->video_dev->minor == minor) {

			zr = zoran[i];

			break;