drivers/media/video/omapgfx/gfx_init.c - kernel/panda - Git at Google

 /*
  * drivers/media/video/omap/v4gfx.c
  *
  * Copyright (C) 2010 Texas Instruments.
  *
  * This file is licensed under the terms of the GNU General Public License
  * version 2. This program is licensed "as is" without any warranty of any
  * kind, whether express or implied.
  *
  */

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/vmalloc.h>
 #include <linux/types.h>
 #include <linux/platform_device.h>
 #include <linux/version.h>

 #include <linux/omap_v4l2_gfx.h>	/* private ioctls */

 #include <media/v4l2-ioctl.h>

 #include "v4gfx.h"
 #include "gfx_bc.h"

 MODULE_AUTHOR("Texas Instruments.");
 MODULE_DESCRIPTION("OMAP V4L2 GFX driver");
 MODULE_LICENSE("GPL");

 /*
  * Device node will be: /dev/video<VOUT_DEVICENODE_SUFFIX>
  * See also /sys/devices/virtual/video4linux/<node>/name which will be
  * whatever the value of VOUT_NAME is
  */
 #define VOUT_DEVICENODE_SUFFIX 100

 static struct gbl_v4gfx *gbl_dev;

 int debug;	/* is used outside this compilation unit too */
 module_param(debug, int, 0644);

 /*
  * If bypass is set then buffer streaming operations will be bypassed. This
  * enables us to check what the raw performance of stack above the V4L2
  * driver is
  */
 static int bypass;
 module_param(bypass, int, 0644);


 static int bypass_vidioc_qbuf(
 	struct file *file, void *fh, struct v4l2_buffer *buf) { return 0; }

 static int bypass_vidioc_dqbuf(
 	struct file *file, void *fh, struct v4l2_buffer *buf) { return 0; }

 static int bypass_vidioc_streamon(
 	struct file *file, void *fh, enum v4l2_buf_type i) { return 0; }

 static int bypass_vidioc_streamoff(
 	struct file *file, void *fh, enum v4l2_buf_type i) { return 0; }

 static long bypass_vidioc_default(
 	struct file *file, void *fh, int cmd, void *arg)
 {
 	struct v4l2_gfx_buf_params *parms = (struct v4l2_gfx_buf_params *)arg;
 	int rv = 0;

 	switch (cmd) {
 	case V4L2_GFX_IOC_CONSUMER:
 		break;
 	case V4L2_GFX_IOC_ACQ:
 		/* In bypass mode default the first buffer */
 		parms->bufid = 0;
 		break;
 	case V4L2_GFX_IOC_REL:
 		break;
 	default:
 		rv = -EINVAL;
 	}
 	return rv;
 }

 /*
  * If the module is put in bypass mode the following ioctls
  * are effectively nops
  */
 static void v4gfx_enable_bypass(void)
 {
 	v4gfx_ioctl_ops.vidioc_qbuf		= bypass_vidioc_qbuf;
 	v4gfx_ioctl_ops.vidioc_dqbuf		= bypass_vidioc_dqbuf;
 	v4gfx_ioctl_ops.vidioc_streamon	= bypass_vidioc_streamon;
 	v4gfx_ioctl_ops.vidioc_streamoff	= bypass_vidioc_streamoff;
 	v4gfx_ioctl_ops.vidioc_default	= bypass_vidioc_default;
 }

 static void v4gfx_cleanup_device(struct v4gfx_device *vout)
 {
 	struct video_device *vfd;

 	if (!vout)
 		return;
 	vfd = vout->vfd;

 	if (vfd) {
 		if (vfd->minor == -1) {
 			/*
 			 * The device was never registered, so release the
 			 * video_device struct directly.
 			 */
 			video_device_release(vfd);
 		} else {
 			/*
 			 * The unregister function will release the video_device
 			 * struct as well as unregistering it.
 			 */
 			video_unregister_device(vfd);
 		}
 	}

 	v4gfx_tiler_buffer_free(vout, vout->buffer_allocated, 0);
 	kfree(vout);
 }

 static int driver_remove(struct platform_device *pdev)
 {
 	struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
 	struct gbl_v4gfx *dev = container_of(v4l2_dev, struct
 			gbl_v4gfx, v4l2_dev);
 	int k;

 	v4l2_device_unregister(v4l2_dev);
 	for (k = 0; k < pdev->num_resources; k++)
 		v4gfx_cleanup_device(dev->vouts[k]);

 	kfree(gbl_dev);
 	return 0;
 }

 static int driver_probe(struct platform_device *pdev)
 {
 	printk(KERN_INFO "Probing: " VOUT_NAME);
 	return 0;
 }

 static int v4gfx_create_instance(struct v4gfx_device **voutp)
 {
 	int r = 0;
 	struct v4gfx_device *vout = NULL;
 	struct video_device *vfd = NULL;

 	vout = kzalloc(sizeof(struct v4gfx_device), GFP_KERNEL);
 	if (vout == NULL) {
 		r = -ENOMEM;
 		goto end;
 	}
 	mutex_init(&vout->lock);
 	spin_lock_init(&vout->vbq_lock);
 	/* TODO set this to an invalid value, need to change unit test though */
 	vout->bpp = RGB565_BPP;
 	vout->gbl_dev = gbl_dev;
 	vout->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;

 	init_timer(&vout->acquire_timer);
 	vout->acquire_timer.function = v4gfx_acquire_timer;
 	vout->acquire_timer.data = (unsigned long)vout;

     init_waitqueue_head(&vout->sync_done);
     init_waitqueue_head(&vout->consumer_wait);

     vfd = vout->vfd = video_device_alloc();
 	if (!vfd)
 		goto end;

 	strlcpy(vfd->name, VOUT_NAME, sizeof(vfd->name));
 	vfd->vfl_type = VFL_TYPE_GRABBER;
 	vfd->release = video_device_release;
 	vfd->ioctl_ops = &v4gfx_ioctl_ops;
 	vfd->fops = &v4gfx_fops;
 	vfd->minor = -1;
 	vfd->debug = debug;

 	r = video_register_device(vfd, VFL_TYPE_GRABBER,
 				  VOUT_DEVICENODE_SUFFIX);
 	if (r < 0)
 		goto end;

 	video_set_drvdata(vfd, vout);

 	*voutp = vout;
 	printk(KERN_INFO VOUT_NAME ":video device registered\n");
 	return 0;
 end:

 	if (vfd)
 		video_device_release(vfd);

 	kfree(vout); /* safe with null vout */

 	return r;
 }

 static void v4gfx_delete_instance(
 	struct v4l2_device *v4l2_dev, struct v4gfx_device *vout)
 {
 	v4l2_info(v4l2_dev, "unregistering /dev/video%d\n", vout->vfd->num);
 	video_unregister_device(vout->vfd);
 	v4gfx_buffer_array_free(vout, vout->buffer_allocated);
 	kfree(vout);
 	return;
 }

 static struct platform_driver v4gfx_driver = {
 	.driver = {
 		   .name = VOUT_NAME,
 		   },
 	.probe = driver_probe,
 	.remove = driver_remove,
 };

 static int module_init_v4gfx(void)
 {
 	int rv;
 	bool v4l2_dev_registered = false;
 	bool bc_dev_registered = false;

 	if (bypass) {
 		printk(KERN_INFO VOUT_NAME ":Enable bypass mode\n");
 		v4gfx_enable_bypass();
 	}

 	rv = platform_driver_register(&v4gfx_driver);
 	if (rv != 0) {
 		printk(KERN_ERR VOUT_NAME ":platform_driver_register failed\n");
 		goto end;
 	}

 	gbl_dev = kzalloc(sizeof(struct gbl_v4gfx), GFP_KERNEL);
 	if (gbl_dev == NULL) {
 		rv = -ENOMEM;
 		goto end;
 	}

 	snprintf(gbl_dev->v4l2_dev.name, sizeof(gbl_dev->v4l2_dev.name),
 			"%s-%03d", VOUT_NAME, VOUT_DEVICENODE_SUFFIX);

 	rv = v4l2_device_register(NULL, &gbl_dev->v4l2_dev);
 	if (rv != 0) {
 		printk(KERN_ERR VOUT_NAME ":v4l2_device_register failed\n");
 		goto end;
 	}
 	v4l2_dev_registered = true;

 	rv = v4gfx_create_instance(&gbl_dev->vouts[0]);
 	if (rv != 0)
 		goto end;

 	rv = bc_init();
 	if (rv != 0)
 		goto end;

 	bc_dev_registered = true;

 	printk(KERN_INFO VOUT_NAME ":OMAP V4L2 GFX driver loaded ok\n");
 	return rv;
 end:
 	printk(KERN_INFO VOUT_NAME ":Error %d loading OMAP V4L2 GFX driver\n",
 									rv);

 	if (bc_dev_registered)
 		bc_cleanup();

 	if (v4l2_dev_registered)
 		v4l2_device_unregister(&gbl_dev->v4l2_dev);

 	kfree(gbl_dev); /* gbl_dev can be null */

 	return rv;
 }

 static void module_exit_v4gfx(void)
 {
 	bc_cleanup();

 	v4gfx_delete_instance(&gbl_dev->v4l2_dev, gbl_dev->vouts[0]);

 	v4l2_device_unregister(&gbl_dev->v4l2_dev);

 	kfree(gbl_dev);

 	platform_driver_unregister(&v4gfx_driver);
 }

 module_init(module_init_v4gfx);
 module_exit(module_exit_v4gfx);
	/*
	* drivers/media/video/omap/v4gfx.c
	*
	* Copyright (C) 2010 Texas Instruments.
	*
	* This file is licensed under the terms of the GNU General Public License
	* version 2. This program is licensed "as is" without any warranty of any
	* kind, whether express or implied.
	*
	*/

	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/errno.h>
	#include <linux/kernel.h>
	#include <linux/vmalloc.h>
	#include <linux/types.h>
	#include <linux/platform_device.h>
	#include <linux/version.h>

	#include <linux/omap_v4l2_gfx.h> /* private ioctls */

	#include <media/v4l2-ioctl.h>

	#include "v4gfx.h"
	#include "gfx_bc.h"

	MODULE_AUTHOR("Texas Instruments.");
	MODULE_DESCRIPTION("OMAP V4L2 GFX driver");
	MODULE_LICENSE("GPL");

	/*
	* Device node will be: /dev/video<VOUT_DEVICENODE_SUFFIX>
	* See also /sys/devices/virtual/video4linux/<node>/name which will be
	* whatever the value of VOUT_NAME is
	*/
	#define VOUT_DEVICENODE_SUFFIX 100

	static struct gbl_v4gfx *gbl_dev;

	int debug; /* is used outside this compilation unit too */
	module_param(debug, int, 0644);

	/*
	* If bypass is set then buffer streaming operations will be bypassed. This
	* enables us to check what the raw performance of stack above the V4L2
	* driver is
	*/
	static int bypass;
	module_param(bypass, int, 0644);


	static int bypass_vidioc_qbuf(
	struct file file, void fh, struct v4l2_buffer *buf) { return 0; }

	static int bypass_vidioc_dqbuf(
	struct file file, void fh, struct v4l2_buffer *buf) { return 0; }

	static int bypass_vidioc_streamon(
	struct file file, void fh, enum v4l2_buf_type i) { return 0; }

	static int bypass_vidioc_streamoff(
	struct file file, void fh, enum v4l2_buf_type i) { return 0; }

	static long bypass_vidioc_default(
	struct file file, void fh, int cmd, void *arg)
	{
	struct v4l2_gfx_buf_params parms = (struct v4l2_gfx_buf_params )arg;
	int rv = 0;

	switch (cmd) {
	case V4L2_GFX_IOC_CONSUMER:
	break;
	case V4L2_GFX_IOC_ACQ:
	/* In bypass mode default the first buffer */
	parms->bufid = 0;
	break;
	case V4L2_GFX_IOC_REL:
	break;
	default:
	rv = -EINVAL;
	}
	return rv;
	}

	/*
	* If the module is put in bypass mode the following ioctls
	* are effectively nops
	*/
	static void v4gfx_enable_bypass(void)
	{
	v4gfx_ioctl_ops.vidioc_qbuf = bypass_vidioc_qbuf;
	v4gfx_ioctl_ops.vidioc_dqbuf = bypass_vidioc_dqbuf;
	v4gfx_ioctl_ops.vidioc_streamon = bypass_vidioc_streamon;
	v4gfx_ioctl_ops.vidioc_streamoff = bypass_vidioc_streamoff;
	v4gfx_ioctl_ops.vidioc_default = bypass_vidioc_default;
	}

	static void v4gfx_cleanup_device(struct v4gfx_device *vout)
	{
	struct video_device *vfd;

	if (!vout)
	return;
	vfd = vout->vfd;

	if (vfd) {
	if (vfd->minor == -1) {
	/*
	* The device was never registered, so release the
	* video_device struct directly.
	*/
	video_device_release(vfd);
	} else {
	/*
	* The unregister function will release the video_device
	* struct as well as unregistering it.
	*/
	video_unregister_device(vfd);
	}
	}

	v4gfx_tiler_buffer_free(vout, vout->buffer_allocated, 0);
	kfree(vout);
	}

	static int driver_remove(struct platform_device *pdev)
	{
	struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
	struct gbl_v4gfx *dev = container_of(v4l2_dev, struct
	gbl_v4gfx, v4l2_dev);
	int k;

	v4l2_device_unregister(v4l2_dev);
	for (k = 0; k < pdev->num_resources; k++)
	v4gfx_cleanup_device(dev->vouts[k]);

	kfree(gbl_dev);
	return 0;
	}

	static int driver_probe(struct platform_device *pdev)
	{
	printk(KERN_INFO "Probing: " VOUT_NAME);
	return 0;
	}

	static int v4gfx_create_instance(struct v4gfx_device **voutp)
	{
	int r = 0;
	struct v4gfx_device *vout = NULL;
	struct video_device *vfd = NULL;

	vout = kzalloc(sizeof(struct v4gfx_device), GFP_KERNEL);
	if (vout == NULL) {
	r = -ENOMEM;
	goto end;
	}
	mutex_init(&vout->lock);
	spin_lock_init(&vout->vbq_lock);
	/* TODO set this to an invalid value, need to change unit test though */
	vout->bpp = RGB565_BPP;
	vout->gbl_dev = gbl_dev;
	vout->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;

	init_timer(&vout->acquire_timer);
	vout->acquire_timer.function = v4gfx_acquire_timer;
	vout->acquire_timer.data = (unsigned long)vout;

	init_waitqueue_head(&vout->sync_done);
	init_waitqueue_head(&vout->consumer_wait);

	vfd = vout->vfd = video_device_alloc();
	if (!vfd)
	goto end;

	strlcpy(vfd->name, VOUT_NAME, sizeof(vfd->name));
	vfd->vfl_type = VFL_TYPE_GRABBER;
	vfd->release = video_device_release;
	vfd->ioctl_ops = &v4gfx_ioctl_ops;
	vfd->fops = &v4gfx_fops;
	vfd->minor = -1;
	vfd->debug = debug;

	r = video_register_device(vfd, VFL_TYPE_GRABBER,
	VOUT_DEVICENODE_SUFFIX);
	if (r < 0)
	goto end;

	video_set_drvdata(vfd, vout);

	*voutp = vout;
	printk(KERN_INFO VOUT_NAME ":video device registered\n");
	return 0;
	end:

	if (vfd)
	video_device_release(vfd);

	kfree(vout); /* safe with null vout */

	return r;
	}

	static void v4gfx_delete_instance(
	struct v4l2_device v4l2_dev, struct v4gfx_device vout)
	{
	v4l2_info(v4l2_dev, "unregistering /dev/video%d\n", vout->vfd->num);
	video_unregister_device(vout->vfd);
	v4gfx_buffer_array_free(vout, vout->buffer_allocated);
	kfree(vout);
	return;
	}

	static struct platform_driver v4gfx_driver = {
	.driver = {
	.name = VOUT_NAME,
	},
	.probe = driver_probe,
	.remove = driver_remove,
	};

	static int module_init_v4gfx(void)
	{
	int rv;
	bool v4l2_dev_registered = false;
	bool bc_dev_registered = false;

	if (bypass) {
	printk(KERN_INFO VOUT_NAME ":Enable bypass mode\n");
	v4gfx_enable_bypass();
	}

	rv = platform_driver_register(&v4gfx_driver);
	if (rv != 0) {
	printk(KERN_ERR VOUT_NAME ":platform_driver_register failed\n");
	goto end;
	}

	gbl_dev = kzalloc(sizeof(struct gbl_v4gfx), GFP_KERNEL);
	if (gbl_dev == NULL) {
	rv = -ENOMEM;
	goto end;
	}

	snprintf(gbl_dev->v4l2_dev.name, sizeof(gbl_dev->v4l2_dev.name),
	"%s-%03d", VOUT_NAME, VOUT_DEVICENODE_SUFFIX);

	rv = v4l2_device_register(NULL, &gbl_dev->v4l2_dev);
	if (rv != 0) {
	printk(KERN_ERR VOUT_NAME ":v4l2_device_register failed\n");
	goto end;
	}
	v4l2_dev_registered = true;

	rv = v4gfx_create_instance(&gbl_dev->vouts[0]);
	if (rv != 0)
	goto end;

	rv = bc_init();
	if (rv != 0)
	goto end;

	bc_dev_registered = true;

	printk(KERN_INFO VOUT_NAME ":OMAP V4L2 GFX driver loaded ok\n");
	return rv;
	end:
	printk(KERN_INFO VOUT_NAME ":Error %d loading OMAP V4L2 GFX driver\n",
	rv);

	if (bc_dev_registered)
	bc_cleanup();

	if (v4l2_dev_registered)
	v4l2_device_unregister(&gbl_dev->v4l2_dev);

	kfree(gbl_dev); /* gbl_dev can be null */

	return rv;
	}

	static void module_exit_v4gfx(void)
	{
	bc_cleanup();

	v4gfx_delete_instance(&gbl_dev->v4l2_dev, gbl_dev->vouts[0]);

	v4l2_device_unregister(&gbl_dev->v4l2_dev);

	kfree(gbl_dev);

	platform_driver_unregister(&v4gfx_driver);
	}

	module_init(module_init_v4gfx);
	module_exit(module_exit_v4gfx);