if ((buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) ||			    (index >= vout->buffer_cnt) || (buf->flags != 0)) {				retval = -EINVAL;				break;			}			pr_debug("VIDIOC_QBUF: %d\n", buf->index);			spin_lock_irqsave(&g_lock, lock_flags);			memcpy(&(vout->v4l2_bufs[index]), buf, sizeof(*buf));			vout->v4l2_bufs[index].flags |= V4L2_BUF_FLAG_QUEUED;			g_buf_q_cnt++;			queue_buf(&vout->ready_q, index);			if (vout->state == STATE_STREAM_PAUSED) {				index = peek_next_buf(&vout->ready_q);				/* if timestamp is 0, then default to 30fps */				if ((vout->v4l2_bufs[index].timestamp.tv_sec ==				     0)				    && (vout->v4l2_bufs[index].timestamp.					tv_usec == 0))					timeout =					    vout->start_jiffies +					    vout->frame_count * HZ / 30;				else					timeout =					    get_jiffies(&vout->v4l2_bufs[index].							timestamp);				if (jiffies >= timeout) {					pr_debug					    ("warning: timer timeout already expired.\n");				}				vout->output_timer.expires = timeout;				pr_debug				    ("QBUF:Add timer %d timeout @ %lu jiffies, "				     "current = %lu\n", index, timeout,				     jiffies);				add_timer(&vout->output_timer);				vout->state = STATE_STREAM_ON;			}			spin_unlock_irqrestore(&g_lock, lock_flags);			break;		}	case VIDIOC_DQBUF:		{			struct v4l2_buffer *buf = arg;			int idx;			pr_debug("VIDIOC_DQBUF: q size = %d\n",				 queue_size(&vout->done_q));			if ((queue_size(&vout->done_q) == 0) &&			    (file->f_flags & O_NONBLOCK)) {				retval = -EAGAIN;				break;			}			if (!wait_event_interruptible_timeout(vout->v4l_bufq,							      queue_size(&vout->									 done_q)							      != 0, 10 * HZ)) {				pr_debug("VIDIOC_DQBUF: timeout\n");				retval = -ETIME;				break;			} else if (signal_pending(current)) {				if(dq_intr_cnt == 0)					pr_debug("VIDIOC_DQBUF: interrupt received\n");				dq_intr_cnt++;				retval = -ERESTARTSYS;				break;			}			idx = dequeue_buf(&vout->done_q);			if (idx == -1) {	/* No frame free */				pr_debug				    ("VIDIOC_DQBUF: no free buffers, returning\n");				retval = -EAGAIN;				break;			}			if ((vout->v4l2_bufs[idx].flags & V4L2_BUF_FLAG_DONE) ==			    0)				pr_debug				    ("VIDIOC_DQBUF: buffer in done q, but not "				     "flagged as done\n");			vout->v4l2_bufs[idx].flags = 0;			memcpy(buf, &(vout->v4l2_bufs[idx]), sizeof(*buf));			pr_debug("VIDIOC_DQBUF: %d\n", buf->index);			break;		}	case VIDIOC_STREAMON:		{			retval = mxc_v4l2out_streamon(vout);			break;		}	case VIDIOC_STREAMOFF:		{			retval = mxc_v4l2out_streamoff(vout);			break;		}	case VIDIOC_G_CTRL:		{			retval = mxc_get_v42lout_control(vout, arg);			break;		}	case VIDIOC_S_CTRL:		{			retval = mxc_set_v42lout_control(vout, arg);			break;		}	case VIDIOC_CROPCAP:		{			struct v4l2_cropcap *cap = arg;			if (cap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {				retval = -EINVAL;				break;			}			cap->bounds = vout->crop_bounds[vout->cur_disp_output];			cap->defrect = vout->crop_bounds[vout->cur_disp_output];			retval = 0;			break;		}	case VIDIOC_G_CROP:		{			struct v4l2_crop *crop = arg;			if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {				retval = -EINVAL;				break;			}			crop->c = vout->crop_current;			break;		}	case VIDIOC_S_CROP:		{			struct v4l2_crop *crop = arg;			struct v4l2_rect *b =			    &(vout->crop_bounds[vout->cur_disp_output]);			if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {				retval = -EINVAL;				break;			}			if (crop->c.height < 0) {				retval = -EINVAL;				break;			}			if (crop->c.width < 0) {				retval = -EINVAL;				break;			}			if (crop->c.top < b->top)				crop->c.top = b->top;			if (crop->c.top > b->top + b->height)				crop->c.top = b->top + b->height;			if (crop->c.height > b->top - crop->c.top + b->height)				crop->c.height =				    b->top - crop->c.top + b->height;			if (crop->c.left < b->left)				crop->c.top = b->left;			if (crop->c.left > b->left + b->width)				crop->c.top = b->left + b->width;			if (crop->c.width > b->left - crop->c.left + b->width)				crop->c.width =				    b->left - crop->c.left + b->width;			/* stride line limitation */			crop->c.height -= crop->c.height % 2;			crop->c.width -= crop->c.width % 2;			vout->crop_current = crop->c;			vout->sdc_fg_buf_size = vout->crop_current.width *			    vout->crop_current.height;			vout->sdc_fg_buf_size *=			    fmt_to_bpp(SDC_FG_FB_FORMAT) / 8;			break;		}	case VIDIOC_ENUMOUTPUT:		{			struct v4l2_output *output = arg;			if ((output->index >= 2) ||			    (vout->output_enabled[output->index] == false)) {				retval = -EINVAL;				break;			}			*output = mxc_outputs[0];			output->name[4] = '0' + output->index;			break;		}	case VIDIOC_G_OUTPUT:		{			int *p_output_num = arg;			*p_output_num = vout->cur_disp_output;			break;		}	case VIDIOC_S_OUTPUT:		{			int *p_output_num = arg;			if ((*p_output_num >= 2) ||			    (vout->output_enabled[*p_output_num] == false)) {				retval = -EINVAL;				break;			}			if (vout->state != STATE_STREAM_OFF) {				retval = -EBUSY;				break;			}			vout->cur_disp_output = *p_output_num;			break;		}	case VIDIOC_G_FBUF:		{			struct v4l2_framebuffer *fb = arg;			*fb = vout->v4l2_fb;			break;		}	case VIDIOC_S_FBUF:		{			struct v4l2_framebuffer *fb = arg;			vout->v4l2_fb = *fb;			vout->v4l2_fb.capability = V4L2_FBUF_CAP_EXTERNOVERLAY;			break;		}	case VIDIOC_ENUM_FMT:	case VIDIOC_TRY_FMT:	case VIDIOC_QUERYCTRL:	case VIDIOC_G_PARM:	case VIDIOC_ENUMSTD:	case VIDIOC_G_STD:	case VIDIOC_S_STD:	case VIDIOC_G_TUNER:	case VIDIOC_S_TUNER:	case VIDIOC_G_FREQUENCY:	case VIDIOC_S_FREQUENCY:	default:		retval = -EINVAL;		break;	}	up(&vout->busy_lock);	return retval;}/* * V4L2 interface - ioctl function * * @return  None */static intmxc_v4l2out_ioctl(struct inode *inode, struct file *file,		  unsigned int cmd, unsigned long arg){	return video_usercopy(inode, file, cmd, arg, mxc_v4l2out_do_ioctl);}/*! * V4L2 interface - mmap function * * @param file          structure file * * * @param vma           structure vm_area_struct * * * @return status       0 Success, EINTR busy lock error, *                      ENOBUFS remap_page error */static int mxc_v4l2out_mmap(struct file *file, struct vm_area_struct *vma){	struct video_device *dev = file->private_data;	unsigned long start = vma->vm_start;	unsigned long size = vma->vm_end - vma->vm_start;	int res = 0;	vout_data *vout = video_get_drvdata(dev);	/* make this _really_ smp-safe */	if (down_interruptible(&vout->busy_lock))		return -EINTR;	/* make buffers write-thru cacheable */	vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) &				     ~L_PTE_BUFFERABLE);	if (remap_pfn_range(vma, start, vma->vm_pgoff, size, vma->vm_page_prot)) {		pr_debug("mxc_mmap(V4L)i - remap_pfn_range failed\n");		res = -ENOBUFS;		goto mxc_mmap_exit;	}      mxc_mmap_exit:	up(&vout->busy_lock);	return res;}/*! * V4L2 interface - poll function * * @param file       structure file * * * @param wait       structure poll_table * * * @return  status   POLLIN | POLLRDNORM */static unsigned int mxc_v4l2out_poll(struct file *file, poll_table * wait){	struct video_device *dev = file->private_data;	vout_data *vout = video_get_drvdata(dev);	wait_queue_head_t *queue = NULL;	int res = POLLIN | POLLRDNORM;	if (down_interruptible(&vout->busy_lock))		return -EINTR;	queue = &vout->v4l_bufq;	poll_wait(file, queue, wait);	up(&vout->busy_lock);	return res;}static struct file_operations mxc_v4l2out_fops = {	.owner = THIS_MODULE,	.open = mxc_v4l2out_open,	.release = mxc_v4l2out_close,	.ioctl = mxc_v4l2out_ioctl,	.mmap = mxc_v4l2out_mmap,	.poll = mxc_v4l2out_poll,};static struct video_device mxc_v4l2out_template = {	.owner = THIS_MODULE,	.name = "MXC Video Output",	.type = 0,	.type2 = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING,	.hardware = 39,	.fops = &mxc_v4l2out_fops,	.release = video_device_release,};/*! * Probe routine for the framebuffer driver. It is called during the * driver binding process.      The following functions are performed in * this routine: Framebuffer initialization, Memory allocation and * mapping, Framebuffer registration, IPU initialization. * * @return      Appropriate error code to the kernel common code */static int mxc_v4l2out_probe(struct platform_device *pdev){	int i;	vout_data *vout;	/*	 * Allocate sufficient memory for the fb structure	 */	g_vout = vout = kmalloc(sizeof(vout_data), GFP_KERNEL);	if (!vout)		return 0;	memset(vout, 0, sizeof(vout_data));	vout->video_dev = video_device_alloc();	if (vout->video_dev == NULL)		return -1;	vout->video_dev->dev = &pdev->dev;	vout->video_dev->minor = -1;	*(vout->video_dev) = mxc_v4l2out_template;	/* register v4l device */	if (video_register_device(vout->video_dev,				  VFL_TYPE_GRABBER, video_nr) == -1) {		pr_debug("video_register_device failed\n");		return 0;	}	pr_debug("mxc_v4l2out: registered device video%d\n",		 vout->video_dev->minor & 0x1f);	video_set_drvdata(vout->video_dev, vout);	init_MUTEX(&vout->param_lock);	init_MUTEX(&vout->busy_lock);	/* setup outputs and cropping */	vout->cur_disp_output = -1;	for (i = 0; i < num_registered_fb; i++) {		char *idstr = registered_fb[i]->fix.id;		if (strncmp(idstr, "DISP", 4) == 0) {			int disp_num = i;			vout->crop_bounds[disp_num].left = 0;			vout->crop_bounds[disp_num].top = 0;			vout->crop_bounds[disp_num].width =			    registered_fb[i]->var.xres;			vout->crop_bounds[disp_num].height =			    registered_fb[i]->var.yres;			vout->output_enabled[disp_num] = true;			vout->output_fb_num[disp_num] = i;			if (vout->cur_disp_output == -1)				vout->cur_disp_output = disp_num;		}	}	vout->crop_current = vout->crop_bounds[vout->cur_disp_output];	/* Setup framebuffer parameters */	vout->v4l2_fb.capability = V4L2_FBUF_CAP_EXTERNOVERLAY;	vout->v4l2_fb.flags = V4L2_FBUF_FLAG_PRIMARY;	return 0;}/*! * This structure contains pointers to the power management callback functions. */static struct platform_driver mxc_v4l2out_driver = {	.driver = {		   .name = "MXC Video Output",		   .owner = THIS_MODULE,		   .bus = &platform_bus_type,		   },	.probe = mxc_v4l2out_probe,	.remove = NULL,};static void camera_platform_release(struct device *device){}static struct platform_device mxc_v4l2out_device = {	.name = "MXC Video Output",	.dev = {		.release = camera_platform_release,		},	.id = 0,};/*! * mxc v4l2 init function * */static int mxc_v4l2out_init(void){	u8 err = 0;	err = platform_driver_register(&mxc_v4l2out_driver);	if (err == 0) {		platform_device_register(&mxc_v4l2out_device);	}	return err;}/*! * mxc v4l2 cleanup function * */static void mxc_v4l2out_clean(void){	pr_debug("unregistering video\n");	video_unregister_device(g_vout->video_dev);	platform_driver_unregister(&mxc_v4l2out_driver);	platform_device_unregister(&mxc_v4l2out_device);	kfree(g_vout);	g_vout = NULL;}module_init(mxc_v4l2out_init);module_exit(mxc_v4l2out_clean);module_param(video_nr, int, 16);MODULE_AUTHOR("Freescale Semiconductor, Inc.");MODULE_DESCRIPTION("V4L2-driver for MXC video output");MODULE_LICENSE("GPL");MODULE_SUPPORTED_DEVICE("video");