[net-next-2.6.git] / drivers / staging / dream / camera / msm_v4l2.c

/*
 *
 * Copyright (C) 2008-2009 QUALCOMM Incorporated.
 *
 */

#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/list.h>
#include <linux/ioctl.h>
#include <linux/spinlock.h>
#include <linux/videodev2.h>
#include <linux/proc_fs.h>
#include <linux/slab.h>
#include <media/v4l2-dev.h>
#include <media/msm_camera.h>
#include <mach/camera.h>
#include <media/v4l2-ioctl.h>
/*#include <linux/platform_device.h>*/

#define MSM_V4L2_START_SNAPSHOT _IOWR('V', BASE_VIDIOC_PRIVATE+1, \
      struct v4l2_buffer)

#define MSM_V4L2_GET_PICTURE    _IOWR('V', BASE_VIDIOC_PRIVATE+2, \
      struct v4l2_buffer)

#define MSM_V4L2_DEVICE_NAME       "msm_v4l2"

#define MSM_V4L2_PROC_NAME         "msm_v4l2"

#define MSM_V4L2_DEVNUM_MPEG2       0
#define MSM_V4L2_DEVNUM_YUV         20

/* HVGA-P (portrait) and HVGA-L (landscape) */
#define MSM_V4L2_WIDTH              480
#define MSM_V4L2_HEIGHT             320

#if 1
#define D(fmt, args...) printk(KERN_INFO "msm_v4l2: " fmt, ##args)
#else
#define D(fmt, args...) do {} while (0)
#endif

#define PREVIEW_FRAMES_NUM 4

struct msm_v4l2_device {
	struct list_head read_queue;
	struct v4l2_format current_cap_format;
	struct v4l2_format current_pix_format;
	struct video_device *pvdev;
	struct msm_v4l2_driver   *drv;
	uint8_t opencnt;

	spinlock_t read_queue_lock;
};

static struct msm_v4l2_device *g_pmsm_v4l2_dev;


static DEFINE_MUTEX(msm_v4l2_opencnt_lock);

static int msm_v4l2_open(struct file *f)
{
	int rc = 0;
	D("%s\n", __func__);
	mutex_lock(&msm_v4l2_opencnt_lock);
	if (!g_pmsm_v4l2_dev->opencnt) {
		rc = g_pmsm_v4l2_dev->drv->open(
				g_pmsm_v4l2_dev->drv->sync,
				MSM_APPS_ID_V4L2);
	}
	g_pmsm_v4l2_dev->opencnt++;
	mutex_unlock(&msm_v4l2_opencnt_lock);
	return rc;
}

static int msm_v4l2_release(struct file *f)
{
	int rc = 0;
	D("%s\n", __func__);
	mutex_lock(&msm_v4l2_opencnt_lock);
	if (!g_pmsm_v4l2_dev->opencnt) {
		g_pmsm_v4l2_dev->opencnt--;
		if (!g_pmsm_v4l2_dev->opencnt) {
			rc = g_pmsm_v4l2_dev->drv->release(
					g_pmsm_v4l2_dev->drv->sync);
		}
	}
	mutex_unlock(&msm_v4l2_opencnt_lock);
	return rc;
}

static unsigned int msm_v4l2_poll(struct file *f, struct poll_table_struct *w)
{
	return g_pmsm_v4l2_dev->drv->drv_poll(g_pmsm_v4l2_dev->drv->sync, f, w);
}

static long msm_v4l2_ioctl(struct file *filep,
			   unsigned int cmd, unsigned long arg)
{
	struct msm_ctrl_cmd *ctrlcmd;

	D("msm_v4l2_ioctl, cmd = %d, %d\n", cmd, __LINE__);

	switch (cmd) {
	case MSM_V4L2_START_SNAPSHOT:

		ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
		if (!ctrlcmd) {
			CDBG("msm_v4l2_ioctl: cannot allocate buffer\n");
			return -ENOMEM;
		}

		ctrlcmd->length     = 0;
		ctrlcmd->value      = NULL;
		ctrlcmd->timeout_ms = 10000;

		D("msm_v4l2_ioctl,  MSM_V4L2_START_SNAPSHOT v4l2 ioctl %d\n",
		cmd);
		ctrlcmd->type = MSM_V4L2_SNAPSHOT;
		return g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync,
							ctrlcmd);

	case MSM_V4L2_GET_PICTURE:
		D("msm_v4l2_ioctl,  MSM_V4L2_GET_PICTURE v4l2 ioctl %d\n", cmd);
		ctrlcmd = (struct msm_ctrl_cmd *)arg;
		return g_pmsm_v4l2_dev->drv->get_pict(
				g_pmsm_v4l2_dev->drv->sync, ctrlcmd);

	default:
		D("msm_v4l2_ioctl, standard v4l2 ioctl %d\n", cmd);
		return video_ioctl2(filep, cmd, arg);
	}
}

static void msm_v4l2_release_dev(struct video_device *d)
{
	D("%s\n", __func__);
}

static int msm_v4l2_querycap(struct file *f,
			     void *pctx, struct v4l2_capability *pcaps)
{
	D("%s\n", __func__);
	strncpy(pcaps->driver, MSM_APPS_ID_V4L2, sizeof(pcaps->driver));
	strncpy(pcaps->card,
		MSM_V4L2_DEVICE_NAME, sizeof(pcaps->card));
	pcaps->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
	return 0;
}

static int msm_v4l2_s_std(struct file *f, void *pctx, v4l2_std_id *pnorm)
{
	D("%s\n", __func__);
	return 0;
}

static int msm_v4l2_queryctrl(struct file *f,
				void *pctx, struct v4l2_queryctrl *pqctrl)
{
  int rc = 0;
  struct msm_ctrl_cmd *ctrlcmd;

	D("%s\n", __func__);

	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
	if (!ctrlcmd) {
		CDBG("msm_v4l2_queryctrl: cannot allocate buffer\n");
		return -ENOMEM;
	}

	ctrlcmd->type       = MSM_V4L2_QUERY_CTRL;
	ctrlcmd->length     = sizeof(struct v4l2_queryctrl);
	ctrlcmd->value      = pqctrl;
	ctrlcmd->timeout_ms = 10000;

	rc = g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
	if (rc < 0)
		return -1;

	return ctrlcmd->status;
}

static int msm_v4l2_g_ctrl(struct file *f, void *pctx, struct v4l2_control *c)
{
	int rc = 0;
	struct msm_ctrl_cmd *ctrlcmd;

	D("%s\n", __func__);

	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
	if (!ctrlcmd) {
		CDBG("msm_v4l2_g_ctrl: cannot allocate buffer\n");
		return -ENOMEM;
	}

	ctrlcmd->type       = MSM_V4L2_GET_CTRL;
	ctrlcmd->length     = sizeof(struct v4l2_control);
	ctrlcmd->value      = c;
	ctrlcmd->timeout_ms = 10000;

	rc = g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
	if (rc < 0)
		return -1;

	return ctrlcmd->status;
}

static int msm_v4l2_s_ctrl(struct file *f, void *pctx, struct v4l2_control *c)
{
	int rc = 0;
	struct msm_ctrl_cmd *ctrlcmd;

	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
	if (!ctrlcmd) {
		CDBG("msm_v4l2_s_ctrl: cannot allocate buffer\n");
		return -ENOMEM;
	}

	ctrlcmd->type       = MSM_V4L2_SET_CTRL;
	ctrlcmd->length     = sizeof(struct v4l2_control);
	ctrlcmd->value      = c;
	ctrlcmd->timeout_ms = 10000;

	D("%s\n", __func__);

	rc = g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
	if (rc < 0)
		return -1;

	return ctrlcmd->status;
}

static int msm_v4l2_reqbufs(struct file *f,
			    void *pctx, struct v4l2_requestbuffers *b)
{
	D("%s\n", __func__);
	return 0;
}

static int msm_v4l2_querybuf(struct file *f, void *pctx, struct v4l2_buffer *pb)
{
	struct msm_pmem_info pmem_buf;
#if 0
	__u32 width = 0;
	__u32 height = 0;
	__u32 y_size = 0;
	__u32 y_pad = 0;

	/* FIXME: g_pmsm_v4l2_dev->current_pix_format.fmt.pix.width; */
	width = 640;
	/* FIXME: g_pmsm_v4l2_dev->current_pix_format.fmt.pix.height; */
	height = 480;

	D("%s: width = %d, height = %d\n", __func__, width, height);

	y_size = width * height;
	y_pad = y_size % 4;
#endif

    __u32 y_pad = pb->bytesused % 4;

	/* V4L2 videodev will do the copy_from_user. */

	memset(&pmem_buf, 0, sizeof(struct msm_pmem_info));
	pmem_buf.type = MSM_PMEM_OUTPUT2;
	pmem_buf.vaddr = (void *)pb->m.userptr;
	pmem_buf.y_off = 0;
	pmem_buf.fd = (int)pb->reserved;
	/* pmem_buf.cbcr_off = (y_size + y_pad); */
    pmem_buf.cbcr_off = (pb->bytesused + y_pad);

	g_pmsm_v4l2_dev->drv->reg_pmem(g_pmsm_v4l2_dev->drv->sync, &pmem_buf);

	return 0;
}

static int msm_v4l2_qbuf(struct file *f, void *pctx, struct v4l2_buffer *pb)
{
    /*
	__u32 y_size = 0;
	__u32 y_pad = 0;
	__u32 width = 0;
	__u32 height = 0;
    */

	__u32 y_pad = 0;

	struct msm_pmem_info meminfo;
	struct msm_frame frame;
	static int cnt;

	if ((pb->flags >> 16) & 0x0001) {
		/* this is for previwe */
#if 0
		width = 640;
		height = 480;

		/* V4L2 videodev will do the copy_from_user. */
		D("%s: width = %d, height = %d\n", __func__, width, height);
		y_size = width * height;
		y_pad = y_size % 4;
#endif

		y_pad = pb->bytesused % 4;

		if (pb->type == V4L2_BUF_TYPE_PRIVATE) {
			/* this qbuf is actually for releasing */

			frame.buffer           = pb->m.userptr;
			frame.y_off            = 0;
			/* frame.cbcr_off = (y_size + y_pad); */
			frame.cbcr_off         = (pb->bytesused + y_pad);
			frame.fd               = pb->reserved;

			D("V4L2_BUF_TYPE_PRIVATE: pb->bytesused = %d \n",
			pb->bytesused);

			g_pmsm_v4l2_dev->drv->put_frame(
				g_pmsm_v4l2_dev->drv->sync,
				&frame);

			return 0;
		}

		D("V4L2_BUF_TYPE_VIDEO_CAPTURE: pb->bytesused = %d \n",
		pb->bytesused);

		meminfo.type             = MSM_PMEM_OUTPUT2;
		meminfo.fd               = (int)pb->reserved;
		meminfo.vaddr            = (void *)pb->m.userptr;
		meminfo.y_off            = 0;
		/* meminfo.cbcr_off = (y_size + y_pad); */
		meminfo.cbcr_off         = (pb->bytesused + y_pad);
		if (cnt == PREVIEW_FRAMES_NUM - 1)
			meminfo.active = 0;
		else
			meminfo.active = 1;
		cnt++;
		g_pmsm_v4l2_dev->drv->reg_pmem(g_pmsm_v4l2_dev->drv->sync,
				&meminfo);
	} else if ((pb->flags) & 0x0001) {
		/* this is for snapshot */

	__u32 y_size = 0;

	if ((pb->flags >> 8) & 0x01) {

		y_size = pb->bytesused;

		meminfo.type = MSM_PMEM_THUMBAIL;
	} else if ((pb->flags >> 9) & 0x01) {

		y_size = pb->bytesused;

		meminfo.type = MSM_PMEM_MAINIMG;
	}

	y_pad = y_size % 4;

	meminfo.fd         = (int)pb->reserved;
	meminfo.vaddr      = (void *)pb->m.userptr;
	meminfo.y_off      = 0;
	/* meminfo.cbcr_off = (y_size + y_pad); */
	meminfo.cbcr_off   = (y_size + y_pad);
	meminfo.active 	   = 1;
	g_pmsm_v4l2_dev->drv->reg_pmem(g_pmsm_v4l2_dev->drv->sync,
					&meminfo);
	}

	return 0;
}

static int msm_v4l2_dqbuf(struct file *f, void *pctx, struct v4l2_buffer *pb)
{
	struct msm_frame frame;
	D("%s\n", __func__);

	/* V4L2 videodev will do the copy_to_user. */
	if (pb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {

		D("%s, %d\n", __func__, __LINE__);

		g_pmsm_v4l2_dev->drv->get_frame(
			g_pmsm_v4l2_dev->drv->sync,
			&frame);

		pb->type       = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		pb->m.userptr  = (unsigned long)frame.buffer;  /* FIXME */
		pb->reserved   = (int)frame.fd;
		/* pb->length     = (int)frame.cbcr_off; */

		pb->bytesused  = frame.cbcr_off;

	} else if (pb->type == V4L2_BUF_TYPE_PRIVATE) {
		__u32 y_pad     = pb->bytesused % 4;

		frame.buffer   = pb->m.userptr;
		frame.y_off    = 0;
		/* frame.cbcr_off = (y_size + y_pad); */
		frame.cbcr_off = (pb->bytesused + y_pad);
		frame.fd       = pb->reserved;

		g_pmsm_v4l2_dev->drv->put_frame(
			g_pmsm_v4l2_dev->drv->sync,
			&frame);
	}

	return 0;
}

static int msm_v4l2_streamon(struct file *f, void *pctx, enum v4l2_buf_type i)
{
  struct msm_ctrl_cmd *ctrlcmd;

	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
	if (!ctrlcmd) {
		CDBG("msm_v4l2_s_fmt_cap: cannot allocate buffer\n");
		return -ENOMEM;
	}

	ctrlcmd->type       = MSM_V4L2_STREAM_ON;
	ctrlcmd->timeout_ms = 10000;
	ctrlcmd->length     = 0;
	ctrlcmd->value      = NULL;

	D("%s\n", __func__);

	g_pmsm_v4l2_dev->drv->ctrl(
		g_pmsm_v4l2_dev->drv->sync,
		ctrlcmd);

	D("%s after drv->ctrl \n", __func__);

	return 0;
}

static int msm_v4l2_streamoff(struct file *f, void *pctx, enum v4l2_buf_type i)
{
  struct msm_ctrl_cmd *ctrlcmd;

	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
	if (!ctrlcmd) {
		CDBG("msm_v4l2_s_fmt_cap: cannot allocate buffer\n");
		return -ENOMEM;
	}

	ctrlcmd->type       = MSM_V4L2_STREAM_OFF;
	ctrlcmd->timeout_ms = 10000;
	ctrlcmd->length     = 0;
	ctrlcmd->value      = NULL;


	D("%s\n", __func__);

	g_pmsm_v4l2_dev->drv->ctrl(
		g_pmsm_v4l2_dev->drv->sync,
		ctrlcmd);

	return 0;
}

static int msm_v4l2_enum_fmt_overlay(struct file *f,
				     void *pctx, struct v4l2_fmtdesc *pfmtdesc)
{
	D("%s\n", __func__);
	return 0;
}

static int msm_v4l2_enum_fmt_cap(struct file *f,
				 void *pctx, struct v4l2_fmtdesc *pfmtdesc)
{
	D("%s\n", __func__);

	switch (pfmtdesc->index) {
	case 0:
		pfmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		pfmtdesc->flags = 0;
		strncpy(pfmtdesc->description, "YUV 4:2:0",
			sizeof(pfmtdesc->description));
		pfmtdesc->pixelformat = V4L2_PIX_FMT_YVU420;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int msm_v4l2_g_fmt_cap(struct file *f,
			      void *pctx, struct v4l2_format *pfmt)
{
	D("%s\n", __func__);
	pfmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	pfmt->fmt.pix.width = MSM_V4L2_WIDTH;
	pfmt->fmt.pix.height = MSM_V4L2_HEIGHT;
	pfmt->fmt.pix.pixelformat = V4L2_PIX_FMT_YVU420;
	pfmt->fmt.pix.field = V4L2_FIELD_ANY;
	pfmt->fmt.pix.bytesperline = 0;
	pfmt->fmt.pix.sizeimage = 0;
	pfmt->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
	pfmt->fmt.pix.priv = 0;
	return 0;
}

static int msm_v4l2_s_fmt_cap(struct file *f,
			      void *pctx, struct v4l2_format *pfmt)
{
  struct msm_ctrl_cmd *ctrlcmd;

	D("%s\n", __func__);

	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
	if (!ctrlcmd) {
		CDBG("msm_v4l2_s_fmt_cap: cannot allocate buffer\n");
		return -ENOMEM;
	}

  ctrlcmd->type       = MSM_V4L2_VID_CAP_TYPE;
  ctrlcmd->length     = sizeof(struct v4l2_format);
  ctrlcmd->value      = pfmt;
  ctrlcmd->timeout_ms = 10000;

	if (pfmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
		kfree(ctrlcmd);
		return -1;
	}

#if 0
	/* FIXEME */
	if (pfmt->fmt.pix.pixelformat != V4L2_PIX_FMT_YVU420) {
		kfree(ctrlcmd);
		return -EINVAL;
	}
#endif

	/* Ok, but check other params, too. */

#if 0
	memcpy(&g_pmsm_v4l2_dev->current_pix_format.fmt.pix, pfmt,
	       sizeof(struct v4l2_format));
#endif

	g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);

	return 0;
}

static int msm_v4l2_g_fmt_overlay(struct file *f,
				  void *pctx, struct v4l2_format *pfmt)
{
	D("%s\n", __func__);
	pfmt->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
	pfmt->fmt.pix.width = MSM_V4L2_WIDTH;
	pfmt->fmt.pix.height = MSM_V4L2_HEIGHT;
	pfmt->fmt.pix.pixelformat = V4L2_PIX_FMT_YVU420;
	pfmt->fmt.pix.field = V4L2_FIELD_ANY;
	pfmt->fmt.pix.bytesperline = 0;
	pfmt->fmt.pix.sizeimage = 0;
	pfmt->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
	pfmt->fmt.pix.priv = 0;
	return 0;
}

static int msm_v4l2_s_fmt_overlay(struct file *f,
				  void *pctx, struct v4l2_format *pfmt)
{
	D("%s\n", __func__);
	return 0;
}

static int msm_v4l2_overlay(struct file *f, void *pctx, unsigned int i)
{
	D("%s\n", __func__);
	return 0;
}

static int msm_v4l2_g_jpegcomp(struct file *f,
			       void *pctx, struct v4l2_jpegcompression *pcomp)
{
	D("%s\n", __func__);
	return 0;
}

static int msm_v4l2_s_jpegcomp(struct file *f,
			       void *pctx, struct v4l2_jpegcompression *pcomp)
{
	D("%s\n", __func__);
	return 0;
}

#ifdef CONFIG_PROC_FS
int msm_v4l2_read_proc(char *pbuf, char **start, off_t offset,
		       int count, int *eof, void *data)
{
	int len = 0;
	len += snprintf(pbuf, strlen("stats\n") + 1, "stats\n");

	if (g_pmsm_v4l2_dev) {
		len += snprintf(pbuf, strlen("mode: ") + 1, "mode: ");

		if (g_pmsm_v4l2_dev->current_cap_format.type
		    == V4L2_BUF_TYPE_VIDEO_CAPTURE)
			len += snprintf(pbuf, strlen("capture\n") + 1,
					"capture\n");
		else
			len += snprintf(pbuf, strlen("unknown\n") + 1,
					"unknown\n");

		len += snprintf(pbuf, 21, "resolution: %dx%d\n",
				g_pmsm_v4l2_dev->current_cap_format.fmt.pix.
				width,
				g_pmsm_v4l2_dev->current_cap_format.fmt.pix.
				height);

		len += snprintf(pbuf,
				strlen("pixel format: ") + 1, "pixel format: ");
		if (g_pmsm_v4l2_dev->current_cap_format.fmt.pix.pixelformat
		    == V4L2_PIX_FMT_YVU420)
			len += snprintf(pbuf, strlen("yvu420\n") + 1,
					"yvu420\n");
		else
			len += snprintf(pbuf, strlen("unknown\n") + 1,
					"unknown\n");

		len += snprintf(pbuf, strlen("colorspace: ") + 1,
				"colorspace: ");
		if (g_pmsm_v4l2_dev->current_cap_format.fmt.pix.colorspace
		    == V4L2_COLORSPACE_JPEG)
			len += snprintf(pbuf, strlen("jpeg\n") + 1, "jpeg\n");
		else
			len += snprintf(pbuf, strlen("unknown\n") + 1,
					"unknown\n");
	}

	*eof = 1;
	return len;
}
#endif

static const struct v4l2_file_operations msm_v4l2_fops = {
	.owner = THIS_MODULE,
	.open = msm_v4l2_open,
	.poll = msm_v4l2_poll,
	.release = msm_v4l2_release,
	.ioctl = msm_v4l2_ioctl,
};

static void msm_v4l2_dev_init(struct msm_v4l2_device *pmsm_v4l2_dev)
{
	pmsm_v4l2_dev->read_queue_lock =
	    __SPIN_LOCK_UNLOCKED(pmsm_v4l2_dev->read_queue_lock);
	INIT_LIST_HEAD(&pmsm_v4l2_dev->read_queue);
}

static int msm_v4l2_try_fmt_cap(struct file *file,
				 void *fh, struct v4l2_format *f)
{
	/* FIXME */
	return 0;
}

static int mm_v4l2_try_fmt_type_private(struct file *file,
					 void *fh, struct v4l2_format *f)
{
	/* FIXME */
	return 0;
}

/*
 * should the following structure be used instead of the code in the function?
 * static const struct v4l2_ioctl_ops msm_v4l2_ioctl_ops = {
 *     .vidioc_querycap = ....
 * }
 */
static const struct v4l2_ioctl_ops msm_ioctl_ops = {
	.vidioc_querycap = msm_v4l2_querycap,
	.vidioc_s_std = msm_v4l2_s_std,

	.vidioc_queryctrl = msm_v4l2_queryctrl,
	.vidioc_g_ctrl = msm_v4l2_g_ctrl,
	.vidioc_s_ctrl = msm_v4l2_s_ctrl,

	.vidioc_reqbufs = msm_v4l2_reqbufs,
	.vidioc_querybuf = msm_v4l2_querybuf,
	.vidioc_qbuf = msm_v4l2_qbuf,
	.vidioc_dqbuf = msm_v4l2_dqbuf,

	.vidioc_streamon = msm_v4l2_streamon,
	.vidioc_streamoff = msm_v4l2_streamoff,

	.vidioc_enum_fmt_vid_overlay = msm_v4l2_enum_fmt_overlay,
	.vidioc_enum_fmt_vid_cap = msm_v4l2_enum_fmt_cap,

	.vidioc_try_fmt_vid_cap = msm_v4l2_try_fmt_cap,
	.vidioc_try_fmt_type_private = mm_v4l2_try_fmt_type_private,

	.vidioc_g_fmt_vid_cap = msm_v4l2_g_fmt_cap,
	.vidioc_s_fmt_vid_cap = msm_v4l2_s_fmt_cap,
	.vidioc_g_fmt_vid_overlay = msm_v4l2_g_fmt_overlay,
	.vidioc_s_fmt_vid_overlay = msm_v4l2_s_fmt_overlay,
	.vidioc_overlay = msm_v4l2_overlay,

	.vidioc_g_jpegcomp = msm_v4l2_g_jpegcomp,
	.vidioc_s_jpegcomp = msm_v4l2_s_jpegcomp,
};

static int msm_v4l2_video_dev_init(struct video_device *pvd)
{
	strncpy(pvd->name, MSM_APPS_ID_V4L2, sizeof(pvd->name));
	pvd->vfl_type = 1;
	pvd->fops = &msm_v4l2_fops;
	pvd->release = msm_v4l2_release_dev;
	pvd->minor = -1;
	pvd->ioctl_ops = &msm_ioctl_ops;
	return msm_v4l2_register(g_pmsm_v4l2_dev->drv);
}

static int __init msm_v4l2_init(void)
{
	int rc = -ENOMEM;
	struct video_device *pvdev = NULL;
	struct msm_v4l2_device *pmsm_v4l2_dev = NULL;
	D("%s\n", __func__);

	pvdev = video_device_alloc();
	if (pvdev == NULL)
		return rc;

	pmsm_v4l2_dev =
		kzalloc(sizeof(struct msm_v4l2_device), GFP_KERNEL);
	if (pmsm_v4l2_dev == NULL) {
		video_device_release(pvdev);
		return rc;
	}

	msm_v4l2_dev_init(pmsm_v4l2_dev);

	g_pmsm_v4l2_dev = pmsm_v4l2_dev;
	g_pmsm_v4l2_dev->pvdev = pvdev;

	g_pmsm_v4l2_dev->drv =
		kzalloc(sizeof(struct msm_v4l2_driver), GFP_KERNEL);
	if (!g_pmsm_v4l2_dev->drv) {
		video_device_release(pvdev);
		kfree(pmsm_v4l2_dev);
		return rc;
	}

	rc = msm_v4l2_video_dev_init(pvdev);
	if (rc < 0) {
		video_device_release(pvdev);
		kfree(g_pmsm_v4l2_dev->drv);
		kfree(pmsm_v4l2_dev);
		return rc;
	}

	if (video_register_device(pvdev, VFL_TYPE_GRABBER,
	    MSM_V4L2_DEVNUM_YUV)) {
		D("failed to register device\n");
		video_device_release(pvdev);
		kfree(g_pmsm_v4l2_dev);
		g_pmsm_v4l2_dev = NULL;
		return -ENOENT;
	}
#ifdef CONFIG_PROC_FS
	create_proc_read_entry(MSM_V4L2_PROC_NAME,
			       0, NULL, msm_v4l2_read_proc, NULL);
#endif

	return 0;
}

static void __exit msm_v4l2_exit(void)
{
	struct video_device *pvdev = g_pmsm_v4l2_dev->pvdev;
	D("%s\n", __func__);
#ifdef CONFIG_PROC_FS
	remove_proc_entry(MSM_V4L2_PROC_NAME, NULL);
#endif
	video_unregister_device(pvdev);
	video_device_release(pvdev);

	msm_v4l2_unregister(g_pmsm_v4l2_dev->drv);

	kfree(g_pmsm_v4l2_dev->drv);
	g_pmsm_v4l2_dev->drv = NULL;

	kfree(g_pmsm_v4l2_dev);
	g_pmsm_v4l2_dev = NULL;
}

module_init(msm_v4l2_init);
module_exit(msm_v4l2_exit);

MODULE_DESCRIPTION("MSM V4L2 driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
eb7b797b BS	1	/*
	2	*
	3	* Copyright (C) 2008-2009 QUALCOMM Incorporated.
	4	*
	5	*/
	6
	7	#include <linux/workqueue.h>
	8	#include <linux/delay.h>
	9	#include <linux/types.h>
	10	#include <linux/list.h>
	11	#include <linux/ioctl.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/videodev2.h>
	14	#include <linux/proc_fs.h>
5a0e3ad6	15	#include <linux/slab.h>
eb7b797b BS	16	#include <media/v4l2-dev.h>
	17	#include <media/msm_camera.h>
	18	#include <mach/camera.h>
	19	#include <media/v4l2-ioctl.h>
	20	/#include <linux/platform_device.h>/
	21
	22	#define MSM_V4L2_START_SNAPSHOT _IOWR('V', BASE_VIDIOC_PRIVATE+1, \
	23	struct v4l2_buffer)
	24
	25	#define MSM_V4L2_GET_PICTURE _IOWR('V', BASE_VIDIOC_PRIVATE+2, \
	26	struct v4l2_buffer)
	27
	28	#define MSM_V4L2_DEVICE_NAME "msm_v4l2"
	29
	30	#define MSM_V4L2_PROC_NAME "msm_v4l2"
	31
	32	#define MSM_V4L2_DEVNUM_MPEG2 0
	33	#define MSM_V4L2_DEVNUM_YUV 20
	34
	35	/* HVGA-P (portrait) and HVGA-L (landscape) */
	36	#define MSM_V4L2_WIDTH 480
	37	#define MSM_V4L2_HEIGHT 320
	38
	39	#if 1
	40	#define D(fmt, args...) printk(KERN_INFO "msm_v4l2: " fmt, ##args)
	41	#else
	42	#define D(fmt, args...) do {} while (0)
	43	#endif
	44
	45	#define PREVIEW_FRAMES_NUM 4
	46
	47	struct msm_v4l2_device {
	48	struct list_head read_queue;
	49	struct v4l2_format current_cap_format;
	50	struct v4l2_format current_pix_format;
	51	struct video_device *pvdev;
	52	struct msm_v4l2_driver *drv;
	53	uint8_t opencnt;
	54
	55	spinlock_t read_queue_lock;
	56	};
	57
	58	static struct msm_v4l2_device *g_pmsm_v4l2_dev;
	59
	60
	61	static DEFINE_MUTEX(msm_v4l2_opencnt_lock);
	62
	63	static int msm_v4l2_open(struct file *f)
	64	{
	65	int rc = 0;
	66	D("%s\n", __func__);
	67	mutex_lock(&msm_v4l2_opencnt_lock);
	68	if (!g_pmsm_v4l2_dev->opencnt) {
	69	rc = g_pmsm_v4l2_dev->drv->open(
	70	g_pmsm_v4l2_dev->drv->sync,
	71	MSM_APPS_ID_V4L2);
	72	}
	73	g_pmsm_v4l2_dev->opencnt++;
	74	mutex_unlock(&msm_v4l2_opencnt_lock);
	75	return rc;
	76	}
	77
	78	static int msm_v4l2_release(struct file *f)
	79	{
80	int rc = 0;
81	D("%s\n", __func__);
82	mutex_lock(&msm_v4l2_opencnt_lock);
83	if (!g_pmsm_v4l2_dev->opencnt) {
84	g_pmsm_v4l2_dev->opencnt--;
85	if (!g_pmsm_v4l2_dev->opencnt) {
86	rc = g_pmsm_v4l2_dev->drv->release(
87	g_pmsm_v4l2_dev->drv->sync);
88	}
89	}
90	mutex_unlock(&msm_v4l2_opencnt_lock);
91	return rc;
92	}
93
94	static unsigned int msm_v4l2_poll(struct file f, struct poll_table_struct w)
95	{
96	return g_pmsm_v4l2_dev->drv->drv_poll(g_pmsm_v4l2_dev->drv->sync, f, w);
97	}
98
99	static long msm_v4l2_ioctl(struct file *filep,
100	unsigned int cmd, unsigned long arg)
101	{
102	struct msm_ctrl_cmd *ctrlcmd;
103
104	D("msm_v4l2_ioctl, cmd = %d, %d\n", cmd, __LINE__);
105
106	switch (cmd) {
107	case MSM_V4L2_START_SNAPSHOT:
108
109	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
110	if (!ctrlcmd) {
111	CDBG("msm_v4l2_ioctl: cannot allocate buffer\n");
112	return -ENOMEM;
113	}
114
115	ctrlcmd->length = 0;
116	ctrlcmd->value = NULL;
117	ctrlcmd->timeout_ms = 10000;
118
119	D("msm_v4l2_ioctl, MSM_V4L2_START_SNAPSHOT v4l2 ioctl %d\n",
120	cmd);
121	ctrlcmd->type = MSM_V4L2_SNAPSHOT;
122	return g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync,
123	ctrlcmd);
124
125	case MSM_V4L2_GET_PICTURE:
126	D("msm_v4l2_ioctl, MSM_V4L2_GET_PICTURE v4l2 ioctl %d\n", cmd);
127	ctrlcmd = (struct msm_ctrl_cmd *)arg;
128	return g_pmsm_v4l2_dev->drv->get_pict(
129	g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
130
131	default:
132	D("msm_v4l2_ioctl, standard v4l2 ioctl %d\n", cmd);
133	return video_ioctl2(filep, cmd, arg);
134	}
135	}
136
137	static void msm_v4l2_release_dev(struct video_device *d)
138	{
139	D("%s\n", __func__);
140	}
141
142	static int msm_v4l2_querycap(struct file *f,
143	void pctx, struct v4l2_capability pcaps)
144	{
145	D("%s\n", __func__);
146	strncpy(pcaps->driver, MSM_APPS_ID_V4L2, sizeof(pcaps->driver));
147	strncpy(pcaps->card,
148	MSM_V4L2_DEVICE_NAME, sizeof(pcaps->card));
149	pcaps->capabilities = V4L2_CAP_VIDEO_CAPTURE \| V4L2_CAP_STREAMING;
150	return 0;
151	}
152
153	static int msm_v4l2_s_std(struct file f, void pctx, v4l2_std_id *pnorm)
154	{
155	D("%s\n", __func__);
156	return 0;
157	}
158
159	static int msm_v4l2_queryctrl(struct file *f,
160	void pctx, struct v4l2_queryctrl pqctrl)
161	{
162	int rc = 0;
163	struct msm_ctrl_cmd *ctrlcmd;
164
165	D("%s\n", __func__);
166
167	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
168	if (!ctrlcmd) {
169	CDBG("msm_v4l2_queryctrl: cannot allocate buffer\n");
170	return -ENOMEM;
171	}
172
173	ctrlcmd->type = MSM_V4L2_QUERY_CTRL;
174	ctrlcmd->length = sizeof(struct v4l2_queryctrl);
175	ctrlcmd->value = pqctrl;
176	ctrlcmd->timeout_ms = 10000;
177
178	rc = g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
179	if (rc < 0)
180	return -1;
181
182	return ctrlcmd->status;
183	}
184
185	static int msm_v4l2_g_ctrl(struct file f, void pctx, struct v4l2_control *c)
186	{
187	int rc = 0;
188	struct msm_ctrl_cmd *ctrlcmd;
189
190	D("%s\n", __func__);
191
192	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
193	if (!ctrlcmd) {
194	CDBG("msm_v4l2_g_ctrl: cannot allocate buffer\n");
195	return -ENOMEM;
196	}
197
198	ctrlcmd->type = MSM_V4L2_GET_CTRL;
199	ctrlcmd->length = sizeof(struct v4l2_control);
200	ctrlcmd->value = c;
201	ctrlcmd->timeout_ms = 10000;
202
203	rc = g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
204	if (rc < 0)
205	return -1;
206
207	return ctrlcmd->status;
208	}
209
210	static int msm_v4l2_s_ctrl(struct file f, void pctx, struct v4l2_control *c)
211	{
212	int rc = 0;
213	struct msm_ctrl_cmd *ctrlcmd;
214
215	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
216	if (!ctrlcmd) {
217	CDBG("msm_v4l2_s_ctrl: cannot allocate buffer\n");
218	return -ENOMEM;
219	}
220
221	ctrlcmd->type = MSM_V4L2_SET_CTRL;
222	ctrlcmd->length = sizeof(struct v4l2_control);
223	ctrlcmd->value = c;
224	ctrlcmd->timeout_ms = 10000;
225
226	D("%s\n", __func__);
227
228	rc = g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
229	if (rc < 0)
230	return -1;
231
232	return ctrlcmd->status;
233	}
234
235	static int msm_v4l2_reqbufs(struct file *f,
236	void pctx, struct v4l2_requestbuffers b)
237	{
238	D("%s\n", __func__);
239	return 0;
240	}
241
242	static int msm_v4l2_querybuf(struct file f, void pctx, struct v4l2_buffer *pb)
243	{
244	struct msm_pmem_info pmem_buf;
245	#if 0
246	__u32 width = 0;
247	__u32 height = 0;
248	__u32 y_size = 0;
249	__u32 y_pad = 0;
250
251	/* FIXME: g_pmsm_v4l2_dev->current_pix_format.fmt.pix.width; */
252	width = 640;
253	/* FIXME: g_pmsm_v4l2_dev->current_pix_format.fmt.pix.height; */
254	height = 480;
255
256	D("%s: width = %d, height = %d\n", __func__, width, height);
257
258	y_size = width * height;
259	y_pad = y_size % 4;
260	#endif
261
262	__u32 y_pad = pb->bytesused % 4;
263
264	/* V4L2 videodev will do the copy_from_user. */
265
266	memset(&pmem_buf, 0, sizeof(struct msm_pmem_info));
267	pmem_buf.type = MSM_PMEM_OUTPUT2;
268	pmem_buf.vaddr = (void *)pb->m.userptr;
269	pmem_buf.y_off = 0;
270	pmem_buf.fd = (int)pb->reserved;
271	/* pmem_buf.cbcr_off = (y_size + y_pad); */
272	pmem_buf.cbcr_off = (pb->bytesused + y_pad);
273
274	g_pmsm_v4l2_dev->drv->reg_pmem(g_pmsm_v4l2_dev->drv->sync, &pmem_buf);
275
276	return 0;
277	}
278
279	static int msm_v4l2_qbuf(struct file f, void pctx, struct v4l2_buffer *pb)
280	{
281	/*
282	__u32 y_size = 0;
283	__u32 y_pad = 0;
284	__u32 width = 0;
285	__u32 height = 0;
286	*/
287
288	__u32 y_pad = 0;
289
290	struct msm_pmem_info meminfo;
291	struct msm_frame frame;
292	static int cnt;
293
294	if ((pb->flags >> 16) & 0x0001) {
295	/* this is for previwe */
296	#if 0
297	width = 640;
298	height = 480;
299
300	/* V4L2 videodev will do the copy_from_user. */
301	D("%s: width = %d, height = %d\n", __func__, width, height);
302	y_size = width * height;
303	y_pad = y_size % 4;
304	#endif
305
306	y_pad = pb->bytesused % 4;
307
308	if (pb->type == V4L2_BUF_TYPE_PRIVATE) {
309	/* this qbuf is actually for releasing */
310
311	frame.buffer = pb->m.userptr;
312	frame.y_off = 0;
313	/* frame.cbcr_off = (y_size + y_pad); */
314	frame.cbcr_off = (pb->bytesused + y_pad);
315	frame.fd = pb->reserved;
316
317	D("V4L2_BUF_TYPE_PRIVATE: pb->bytesused = %d \n",
318	pb->bytesused);
319
320	g_pmsm_v4l2_dev->drv->put_frame(
321	g_pmsm_v4l2_dev->drv->sync,
322	&frame);
323
324	return 0;
325	}
326
327	D("V4L2_BUF_TYPE_VIDEO_CAPTURE: pb->bytesused = %d \n",
328	pb->bytesused);
329
330	meminfo.type = MSM_PMEM_OUTPUT2;
331	meminfo.fd = (int)pb->reserved;
332	meminfo.vaddr = (void *)pb->m.userptr;
333	meminfo.y_off = 0;
334	/* meminfo.cbcr_off = (y_size + y_pad); */
335	meminfo.cbcr_off = (pb->bytesused + y_pad);
336	if (cnt == PREVIEW_FRAMES_NUM - 1)
337	meminfo.active = 0;
338	else
339	meminfo.active = 1;
340	cnt++;
341	g_pmsm_v4l2_dev->drv->reg_pmem(g_pmsm_v4l2_dev->drv->sync,
342	&meminfo);
343	} else if ((pb->flags) & 0x0001) {
344	/* this is for snapshot */
345
346	__u32 y_size = 0;
347
348	if ((pb->flags >> 8) & 0x01) {
349
350	y_size = pb->bytesused;
351
352	meminfo.type = MSM_PMEM_THUMBAIL;
353	} else if ((pb->flags >> 9) & 0x01) {
354
355	y_size = pb->bytesused;
356
357	meminfo.type = MSM_PMEM_MAINIMG;
358	}
359
360	y_pad = y_size % 4;
361
362	meminfo.fd = (int)pb->reserved;
363	meminfo.vaddr = (void *)pb->m.userptr;
364	meminfo.y_off = 0;
365	/* meminfo.cbcr_off = (y_size + y_pad); */
366	meminfo.cbcr_off = (y_size + y_pad);
367	meminfo.active = 1;
368	g_pmsm_v4l2_dev->drv->reg_pmem(g_pmsm_v4l2_dev->drv->sync,
369	&meminfo);
370	}
371
372	return 0;
373	}
374
375	static int msm_v4l2_dqbuf(struct file f, void pctx, struct v4l2_buffer *pb)
376	{
377	struct msm_frame frame;
378	D("%s\n", __func__);
379
380	/* V4L2 videodev will do the copy_to_user. */
381	if (pb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
382
383	D("%s, %d\n", __func__, __LINE__);
384
385	g_pmsm_v4l2_dev->drv->get_frame(
386	g_pmsm_v4l2_dev->drv->sync,
387	&frame);
388
389	pb->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
390	pb->m.userptr = (unsigned long)frame.buffer; /* FIXME */
391	pb->reserved = (int)frame.fd;
392	/* pb->length = (int)frame.cbcr_off; */
393
394	pb->bytesused = frame.cbcr_off;
395
396	} else if (pb->type == V4L2_BUF_TYPE_PRIVATE) {
397	__u32 y_pad = pb->bytesused % 4;
398
399	frame.buffer = pb->m.userptr;
400	frame.y_off = 0;
401	/* frame.cbcr_off = (y_size + y_pad); */
402	frame.cbcr_off = (pb->bytesused + y_pad);
403	frame.fd = pb->reserved;
404
405	g_pmsm_v4l2_dev->drv->put_frame(
406	g_pmsm_v4l2_dev->drv->sync,
407	&frame);
408	}
409
410	return 0;
411	}
412
413	static int msm_v4l2_streamon(struct file f, void pctx, enum v4l2_buf_type i)
414	{
415	struct msm_ctrl_cmd *ctrlcmd;
416
417	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
418	if (!ctrlcmd) {
419	CDBG("msm_v4l2_s_fmt_cap: cannot allocate buffer\n");
420	return -ENOMEM;
421	}
422
423	ctrlcmd->type = MSM_V4L2_STREAM_ON;
424	ctrlcmd->timeout_ms = 10000;
425	ctrlcmd->length = 0;
426	ctrlcmd->value = NULL;
427
428	D("%s\n", __func__);
429
430	g_pmsm_v4l2_dev->drv->ctrl(
431	g_pmsm_v4l2_dev->drv->sync,
432	ctrlcmd);
433
434	D("%s after drv->ctrl \n", __func__);
435
436	return 0;
437	}
438
439	static int msm_v4l2_streamoff(struct file f, void pctx, enum v4l2_buf_type i)
440	{
441	struct msm_ctrl_cmd *ctrlcmd;
442
443	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
444	if (!ctrlcmd) {
445	CDBG("msm_v4l2_s_fmt_cap: cannot allocate buffer\n");
446	return -ENOMEM;
447	}
448
449	ctrlcmd->type = MSM_V4L2_STREAM_OFF;
450	ctrlcmd->timeout_ms = 10000;
451	ctrlcmd->length = 0;
452	ctrlcmd->value = NULL;
453
454
455	D("%s\n", __func__);
456
457	g_pmsm_v4l2_dev->drv->ctrl(
458	g_pmsm_v4l2_dev->drv->sync,
459	ctrlcmd);
460
461	return 0;
462	}
463
464	static int msm_v4l2_enum_fmt_overlay(struct file *f,
465	void pctx, struct v4l2_fmtdesc pfmtdesc)
466	{
467	D("%s\n", __func__);
468	return 0;
469	}
470
471	static int msm_v4l2_enum_fmt_cap(struct file *f,
472	void pctx, struct v4l2_fmtdesc pfmtdesc)
473	{
474	D("%s\n", __func__);
475
476	switch (pfmtdesc->index) {
477	case 0:
478	pfmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
479	pfmtdesc->flags = 0;
480	strncpy(pfmtdesc->description, "YUV 4:2:0",
481	sizeof(pfmtdesc->description));
482	pfmtdesc->pixelformat = V4L2_PIX_FMT_YVU420;
483	break;
484	default:
485	return -EINVAL;
486	}
487
488	return 0;
489	}
490
491	static int msm_v4l2_g_fmt_cap(struct file *f,
492	void pctx, struct v4l2_format pfmt)
493	{
494	D("%s\n", __func__);
495	pfmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
496	pfmt->fmt.pix.width = MSM_V4L2_WIDTH;
497	pfmt->fmt.pix.height = MSM_V4L2_HEIGHT;
498	pfmt->fmt.pix.pixelformat = V4L2_PIX_FMT_YVU420;
499	pfmt->fmt.pix.field = V4L2_FIELD_ANY;
500	pfmt->fmt.pix.bytesperline = 0;
501	pfmt->fmt.pix.sizeimage = 0;
502	pfmt->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
503	pfmt->fmt.pix.priv = 0;
504	return 0;
505	}
506
507	static int msm_v4l2_s_fmt_cap(struct file *f,
508	void pctx, struct v4l2_format pfmt)
509	{
510	struct msm_ctrl_cmd *ctrlcmd;
511
512	D("%s\n", __func__);
513
514	ctrlcmd = kmalloc(sizeof(struct msm_ctrl_cmd), GFP_ATOMIC);
515	if (!ctrlcmd) {
516	CDBG("msm_v4l2_s_fmt_cap: cannot allocate buffer\n");
517	return -ENOMEM;
518	}
519
520	ctrlcmd->type = MSM_V4L2_VID_CAP_TYPE;
521	ctrlcmd->length = sizeof(struct v4l2_format);
522	ctrlcmd->value = pfmt;
523	ctrlcmd->timeout_ms = 10000;
524
2bb6a12a JL	525	if (pfmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2bb6a12a JL	526	kfree(ctrlcmd);
eb7b797b	527	return -1;
2bb6a12a	528	}
eb7b797b BS	529
	530	#if 0
	531	/* FIXEME */
2bb6a12a JL	532	if (pfmt->fmt.pix.pixelformat != V4L2_PIX_FMT_YVU420) {
2bb6a12a JL	533	kfree(ctrlcmd);
eb7b797b	534	return -EINVAL;
2bb6a12a	535	}
eb7b797b BS	536	#endif
	537
	538	/* Ok, but check other params, too. */
	539
	540	#if 0
	541	memcpy(&g_pmsm_v4l2_dev->current_pix_format.fmt.pix, pfmt,
	542	sizeof(struct v4l2_format));
	543	#endif
	544
	545	g_pmsm_v4l2_dev->drv->ctrl(g_pmsm_v4l2_dev->drv->sync, ctrlcmd);
	546
	547	return 0;
	548	}
	549
	550	static int msm_v4l2_g_fmt_overlay(struct file *f,
	551	void pctx, struct v4l2_format pfmt)
	552	{
	553	D("%s\n", __func__);
	554	pfmt->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
	555	pfmt->fmt.pix.width = MSM_V4L2_WIDTH;
	556	pfmt->fmt.pix.height = MSM_V4L2_HEIGHT;
	557	pfmt->fmt.pix.pixelformat = V4L2_PIX_FMT_YVU420;
	558	pfmt->fmt.pix.field = V4L2_FIELD_ANY;
	559	pfmt->fmt.pix.bytesperline = 0;
	560	pfmt->fmt.pix.sizeimage = 0;
	561	pfmt->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
	562	pfmt->fmt.pix.priv = 0;
	563	return 0;
	564	}
	565
	566	static int msm_v4l2_s_fmt_overlay(struct file *f,
	567	void pctx, struct v4l2_format pfmt)
	568	{
	569	D("%s\n", __func__);
	570	return 0;
	571	}
	572
	573	static int msm_v4l2_overlay(struct file f, void pctx, unsigned int i)
	574	{
	575	D("%s\n", __func__);
	576	return 0;
	577	}
	578
	579	static int msm_v4l2_g_jpegcomp(struct file *f,
	580	void pctx, struct v4l2_jpegcompression pcomp)
	581	{
	582	D("%s\n", __func__);
	583	return 0;
	584	}
	585
	586	static int msm_v4l2_s_jpegcomp(struct file *f,
	587	void pctx, struct v4l2_jpegcompression pcomp)
	588	{
	589	D("%s\n", __func__);
	590	return 0;
	591	}
	592
	593	#ifdef CONFIG_PROC_FS
	594	int msm_v4l2_read_proc(char pbuf, char *start, off_t offset,
	595	int count, int eof, void data)
	596	{
	597	int len = 0;
	598	len += snprintf(pbuf, strlen("stats\n") + 1, "stats\n");
	599
600	if (g_pmsm_v4l2_dev) {
601	len += snprintf(pbuf, strlen("mode: ") + 1, "mode: ");
602
603	if (g_pmsm_v4l2_dev->current_cap_format.type
604	== V4L2_BUF_TYPE_VIDEO_CAPTURE)
605	len += snprintf(pbuf, strlen("capture\n") + 1,
606	"capture\n");
607	else
608	len += snprintf(pbuf, strlen("unknown\n") + 1,
609	"unknown\n");
610
611	len += snprintf(pbuf, 21, "resolution: %dx%d\n",
612	g_pmsm_v4l2_dev->current_cap_format.fmt.pix.
613	width,
614	g_pmsm_v4l2_dev->current_cap_format.fmt.pix.
615	height);
616
617	len += snprintf(pbuf,
618	strlen("pixel format: ") + 1, "pixel format: ");
619	if (g_pmsm_v4l2_dev->current_cap_format.fmt.pix.pixelformat
620	== V4L2_PIX_FMT_YVU420)
621	len += snprintf(pbuf, strlen("yvu420\n") + 1,
622	"yvu420\n");
623	else
624	len += snprintf(pbuf, strlen("unknown\n") + 1,
625	"unknown\n");
626
627	len += snprintf(pbuf, strlen("colorspace: ") + 1,
628	"colorspace: ");
629	if (g_pmsm_v4l2_dev->current_cap_format.fmt.pix.colorspace
630	== V4L2_COLORSPACE_JPEG)
631	len += snprintf(pbuf, strlen("jpeg\n") + 1, "jpeg\n");
632	else
633	len += snprintf(pbuf, strlen("unknown\n") + 1,
634	"unknown\n");
635	}
636
637	*eof = 1;
638	return len;
639	}
640	#endif
641
642	static const struct v4l2_file_operations msm_v4l2_fops = {
643	.owner = THIS_MODULE,
644	.open = msm_v4l2_open,
645	.poll = msm_v4l2_poll,
646	.release = msm_v4l2_release,
647	.ioctl = msm_v4l2_ioctl,
648	};
649
650	static void msm_v4l2_dev_init(struct msm_v4l2_device *pmsm_v4l2_dev)
651	{
652	pmsm_v4l2_dev->read_queue_lock =
653	__SPIN_LOCK_UNLOCKED(pmsm_v4l2_dev->read_queue_lock);
654	INIT_LIST_HEAD(&pmsm_v4l2_dev->read_queue);
655	}
656
657	static int msm_v4l2_try_fmt_cap(struct file *file,
658	void fh, struct v4l2_format f)
659	{
660	/* FIXME */
661	return 0;
662	}
663
664	static int mm_v4l2_try_fmt_type_private(struct file *file,
665	void fh, struct v4l2_format f)
666	{
667	/* FIXME */
668	return 0;
669	}
670
671	/*
672	* should the following structure be used instead of the code in the function?
673	* static const struct v4l2_ioctl_ops msm_v4l2_ioctl_ops = {
674	* .vidioc_querycap = ....
675	* }
676	*/
677	static const struct v4l2_ioctl_ops msm_ioctl_ops = {
678	.vidioc_querycap = msm_v4l2_querycap,
679	.vidioc_s_std = msm_v4l2_s_std,
680
681	.vidioc_queryctrl = msm_v4l2_queryctrl,
682	.vidioc_g_ctrl = msm_v4l2_g_ctrl,
683	.vidioc_s_ctrl = msm_v4l2_s_ctrl,
684
685	.vidioc_reqbufs = msm_v4l2_reqbufs,
686	.vidioc_querybuf = msm_v4l2_querybuf,
687	.vidioc_qbuf = msm_v4l2_qbuf,
688	.vidioc_dqbuf = msm_v4l2_dqbuf,
689
690	.vidioc_streamon = msm_v4l2_streamon,
691	.vidioc_streamoff = msm_v4l2_streamoff,
692
693	.vidioc_enum_fmt_vid_overlay = msm_v4l2_enum_fmt_overlay,
694	.vidioc_enum_fmt_vid_cap = msm_v4l2_enum_fmt_cap,
695
696	.vidioc_try_fmt_vid_cap = msm_v4l2_try_fmt_cap,
697	.vidioc_try_fmt_type_private = mm_v4l2_try_fmt_type_private,
698
699	.vidioc_g_fmt_vid_cap = msm_v4l2_g_fmt_cap,
700	.vidioc_s_fmt_vid_cap = msm_v4l2_s_fmt_cap,
701	.vidioc_g_fmt_vid_overlay = msm_v4l2_g_fmt_overlay,
702	.vidioc_s_fmt_vid_overlay = msm_v4l2_s_fmt_overlay,
703	.vidioc_overlay = msm_v4l2_overlay,
704
705	.vidioc_g_jpegcomp = msm_v4l2_g_jpegcomp,
706	.vidioc_s_jpegcomp = msm_v4l2_s_jpegcomp,
707	};
708
709	static int msm_v4l2_video_dev_init(struct video_device *pvd)
710	{
711	strncpy(pvd->name, MSM_APPS_ID_V4L2, sizeof(pvd->name));
712	pvd->vfl_type = 1;
713	pvd->fops = &msm_v4l2_fops;
714	pvd->release = msm_v4l2_release_dev;
715	pvd->minor = -1;
716	pvd->ioctl_ops = &msm_ioctl_ops;
717	return msm_v4l2_register(g_pmsm_v4l2_dev->drv);
718	}
719
720	static int __init msm_v4l2_init(void)
721	{
722	int rc = -ENOMEM;
723	struct video_device *pvdev = NULL;
724	struct msm_v4l2_device *pmsm_v4l2_dev = NULL;
725	D("%s\n", __func__);
726
727	pvdev = video_device_alloc();
728	if (pvdev == NULL)
729	return rc;
730
731	pmsm_v4l2_dev =
732	kzalloc(sizeof(struct msm_v4l2_device), GFP_KERNEL);
733	if (pmsm_v4l2_dev == NULL) {
734	video_device_release(pvdev);
735	return rc;
736	}
737
738	msm_v4l2_dev_init(pmsm_v4l2_dev);
739
740	g_pmsm_v4l2_dev = pmsm_v4l2_dev;
741	g_pmsm_v4l2_dev->pvdev = pvdev;
742
743	g_pmsm_v4l2_dev->drv =
744	kzalloc(sizeof(struct msm_v4l2_driver), GFP_KERNEL);
745	if (!g_pmsm_v4l2_dev->drv) {
746	video_device_release(pvdev);
747	kfree(pmsm_v4l2_dev);
748	return rc;
749	}
750
751	rc = msm_v4l2_video_dev_init(pvdev);
752	if (rc < 0) {
753	video_device_release(pvdev);
754	kfree(g_pmsm_v4l2_dev->drv);
755	kfree(pmsm_v4l2_dev);
756	return rc;
757	}
758
759	if (video_register_device(pvdev, VFL_TYPE_GRABBER,
760	MSM_V4L2_DEVNUM_YUV)) {
761	D("failed to register device\n");
762	video_device_release(pvdev);
763	kfree(g_pmsm_v4l2_dev);
764	g_pmsm_v4l2_dev = NULL;
765	return -ENOENT;
766	}
767	#ifdef CONFIG_PROC_FS
768	create_proc_read_entry(MSM_V4L2_PROC_NAME,
769	0, NULL, msm_v4l2_read_proc, NULL);
770	#endif
771
772	return 0;
773	}
774
775	static void __exit msm_v4l2_exit(void)
776	{
777	struct video_device *pvdev = g_pmsm_v4l2_dev->pvdev;
778	D("%s\n", __func__);
779	#ifdef CONFIG_PROC_FS
780	remove_proc_entry(MSM_V4L2_PROC_NAME, NULL);
781	#endif
782	video_unregister_device(pvdev);
783	video_device_release(pvdev);
784
785	msm_v4l2_unregister(g_pmsm_v4l2_dev->drv);
786
787	kfree(g_pmsm_v4l2_dev->drv);
788	g_pmsm_v4l2_dev->drv = NULL;
789
790	kfree(g_pmsm_v4l2_dev);
791	g_pmsm_v4l2_dev = NULL;
792	}
793
794	module_init(msm_v4l2_init);
795	module_exit(msm_v4l2_exit);
796
797	MODULE_DESCRIPTION("MSM V4L2 driver");
798	MODULE_LICENSE("GPL v2");