DM6446的视频前端VPFE驱动之ioctl控制（视频缓存区，CCDC，decoder)解析之二

最新推荐文章于 2022-11-22 16:04:46 发布

天才2012

最新推荐文章于 2022-11-22 16:04:46 发布

阅读量6.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： linux Linux下底层驱动开发程序语言 TI Davnic视频编解码文章标签： buffer struct list stream generator video

本文链接：https://blog.youkuaiyun.com/gzzaigcnforever/article/details/7754066

linux 同时被 3 个专栏收录

62 篇文章

订阅专栏

程序语言

31 篇文章

订阅专栏

Linux下底层驱动开发

17 篇文章

订阅专栏

本文均属自己阅读源码的点滴总结，转账请注明出处谢谢。

欢迎和大家交流。qq:1037701636 email:200803090209@zjut.com，gzzaigcn2012@gmail.com

本文承接上文的主要内容，对视频缓存区队列的相关执行过程进行一个解析。先给出之前的应用层的调用流程

本文主要涉及到的命令为VIDIOC_QBUF，VIDIOC_DQBUF，VIDIOC_STREAMON。

1.VIDIOC_QBUF命令

这个命令实际的内容可理解为进行缓存区队列的入列操作。也许这样说比较抽象，但是看过源码后就很好理解。在源码中会调用videobuf_qbuf函数，其中主要由buf_prepare指针函数来完成缓存区队列的准备

static int buffer_prepare(struct videobuf_queue *q,
			  struct videobuf_buffer *vb, enum v4l2_field field)
{
	vpfe_obj *vpfe = &vpfe_device;
	unsigned int buf_size;
	dev_dbg(vpfe_dev, "\nstarting buffer_prepare");
	if (device_type == TVP5146) {
		buf_size = VPFE_TVP5146_MAX_FBUF_SIZE;
	} else {
		buf_size = VPFE_MT9T001_MAX_FBUF_SIZE;
	}
	if (vb->state == STATE_NEEDS_INIT) {
		vb->width = vpfe->vwin.width; //720
		vb->height = vpfe->vwin.height; //576
		vb->size = buf_size;  //216*4K
		vb->field = field;  //V4L2_FIELD_INTERLACED
	}
	vb->state = STATE_PREPARED;
	dev_dbg(vpfe_dev, "\nEnd of buffer_prepare");
	return 0;

}

我们可以发现，他将每一个缓存区的状态设置为了STATE_PREPARED。随后执行list_add_tail(&buf->stream,&q->stream);完成将缓存区的stream链表数据添加到整个缓存区队列的stream中。

2.VIDIOC_STREAMON命令

在完成之前的缓存区申请，已经mmap的相关操作之后，就会执行该命令行的系统调用，在这个命令行中，主要完成的是Dm6446的视频前端VPFE的相关硬件初始化，Tvp5416的初始化。

case VIDIOC_STREAMON:  //启动视频流采集
		dev_dbg(vpfe_dev, "\nStarting VIDIOC_STREAMON ioctl");
		if (!fh->io_allowed) {
			ret = -EACCES;
			break;
		}
		if (vpfe->started) {
			ret = -EBUSY;
			break;
		}
		ret = videobuf_streamon(&vpfe->bufqueue);
		if (ret)
			break;

		down_interruptible(&vpfe->lock);
		/* get the current and next frame buffers */
		/* we expect at least one buffer is in driver at this point */
		/* if not, error is returned */
		if (list_empty(&vpfe->dma_queue)) {
			ret = -EIO;
			break;
		}
		dev_dbg(vpfe_dev, "cur frame %x.\n",
			(unsigned int)vpfe->dma_queue.next);
		vpfe->nextFrm = vpfe->curFrm =
		    list_entry(vpfe->dma_queue.next,
			       struct videobuf_buffer, queue);
		/* remove the buffer from the queue */
		list_del(&vpfe->curFrm->queue);
		vpfe->curFrm->state = STATE_ACTIVE;//确保有一个缓存区在缓存区队列中

		if (device_type == TVP5146) {
			/* sense the current video input standard */
			tvp5146_ctrl(TVP5146_CONFIG, &vpfe->tvp5146_params);  //5146完成相关的配置
			frm_format = vpfe_device.ccdc_params_ycbcr.frm_fmt;
			image_window = vpfe_device.ccdc_params_ycbcr.win;
			/* configure the ccdc and resizer as needed   */
			/* start capture by enabling CCDC and resizer */
			ccdc_config_ycbcr(&vpfe->ccdc_params_ycbcr); //ccdc配置为YCbCr格式
		} else {
			frm_format = vpfe_device.ccdc_params_raw.frm_fmt;
			image_window = vpfe_device.ccdc_params_raw.win;
			/* configure the ccdc and resizer as needed   */
			/* start capture by enabling CCDC and resizer */
			ccdc_config_raw(&vpfe->ccdc_params_raw);
			/* enable internal timing generator */
			ccdc_vdhd_enable(TRUE);
		}

		/* setup the memory address for the frame buffer */
		ccdc_setfbaddr(((unsigned long)(vpfe->curFrm->boff)));//32-bit SDRAM starting address for CCD controller output
		/* enable CCDC */
		vpfe->field_id = 0;//设为0
		vpfe->started = TRUE;
		vpfe->mode_changed = FALSE;
		vpfe->field_offset = (vpfe->vwin.height - 2) * vpfe->vwin.width;
		ccdc_enable(TRUE);//启动CCDC进行视频的采集
		up(&vpfe->lock);
		dev_dbg(vpfe_dev, "started video streaming.\n");
		break;

首先会调用videobuf_streamon函数，在该函数中执行q->streaming = 1;//表示当前的缓存区队列已经处于视频流启动。随后进行缓存区链表的遍历，看当前缓存区是否已经处于STATE_PREPARED状态，因为之前已经执行VIDIOC_QBUF命令所以当前就会执行buffer_queue指针函数。

static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
{
	vpfe_obj *vpfe = &vpfe_device;
	/* add the buffer to the DMA queue */
	dev_dbg(vpfe_dev, "\nstarting buffer_queue");
	list_add_tail(&vb->queue, &vpfe->dma_queue);//视频缓存区添加到DMA队列
	vb->state = STATE_QUEUED;
	dev_dbg(vpfe_dev, "\nEnding buffer_queue");
}

在这部分代码中主要实现，将当前的缓存区的链表数据加入到vpfe实体的dma链表头中，完成所谓的入列操作。并将当前状态设置为STATE_QUEUED。以此形成dma带领多个缓存区实体（以链表的形式存在）如下图：

最终会在内核形成形成这样一个链表形式。

在VIDIOC_STREAMON命令中所做的内容还有获取当前视频帧缓存区和下一个帧的缓存区，使curfrm=nextfrm，随后就将Buffer[0]的queue从dma_queue的链表中去除，主要用于在中断中对当前数据帧所存放的缓存区进行调度。应该来说这是整个缓存区合理使用的核心所做。过会再中断函数中介绍。

当然CCDC和TVP5416的相关初始化也在该命令行完成，包括各种硬件寄存器的设置，这些是VPFE能否正常工作的前提所在。完成好相关的参数设置后，使用ccdc_enable（true )启动CCDC模块，开始视频流的采集。

3.依据我的分析，启动CCDC后会立马产生一个偶场数据采集的中断，CCDC的中断VINT0（在中断中优先级最高），中断的回调函数如下：

static irqreturn_t vpfe_isr(int irq, void *dev_id, struct pt_regs *regs)
{
	vpfe_obj *vpfe = &vpfe_device;
	int fid;
	unsigned long jiffies_time = get_jiffies_64();
	struct timeval timevalue;
	int val = 0;

	val = ccdc_sbl_reset();

	/*Convert time representations between jiffies and struct timeval */
	jiffies_to_timeval(jiffies_time, &timevalue);

	dev_dbg(vpfe_dev, "\nStarting Davinci_vpfe\vpfe_isr...");
	if (frm_format == CCDC_FRMFMT_INTERLACED) {
		/* check which field we are in hardware */
		fid = ccdc_getfid();  //获取当前采集的场
		/* switch the software maintained field id */
		vpfe->field_id ^= 1;//field_id为1则结果为0，即vpfe->field_id=0为偶场，反之为1
		dev_dbg(vpfe_dev, "field id = %x:%x.\n", fid, vpfe->field_id);
		if (fid == vpfe->field_id) {	/* we are in-sync here,continue */
			if (fid == 0) {	/* even field */  //偶场
				/*  One frame is just being captured. If the 
				 * next frame is available, release the current 
				 * frame and move on 
				 */
				if (vpfe->curFrm != vpfe->nextFrm) {
					/* Copy frame capture time value in 
					 * curFrm->ts 
					 */
					vpfe->curFrm->ts = timevalue;
					vpfe->curFrm->state = STATE_DONE;
					wake_up_interruptible(&vpfe->
							      curFrm->done);
					vpfe->curFrm = vpfe->nextFrm;
				}
				/* based on whether the two fields are stored  
				 * interleavely or separately in memory, 
				 * reconfigure the CCDC memory address 
				 */
				if (vpfe->field == V4L2_FIELD_SEQ_TB) {
					u32 addr =
					    vpfe->curFrm->boff +
					    vpfe->field_offset;
					ccdc_setfbaddr((unsigned long)
						       addr);
				}
			} else if (fid == 1) {	/* odd field */
				/* if one field is just being captured */
				/* configure the next frame */
				/* get the next frame from the empty queue */
				/* if no frame is available, */
				/* hold on to the current buffer */
				if (!list_empty(&vpfe->dma_queue)       //奇场处理
				    && vpfe->curFrm == vpfe->nextFrm) {
					vpfe->nextFrm =
					    list_entry(vpfe->dma_queue.
						       next, struct
						       videobuf_buffer, queue);
					list_del(&vpfe->nextFrm->queue);
					vpfe->nextFrm->state = STATE_ACTIVE;
					ccdc_setfbaddr((unsigned long)
						       vpfe->nextFrm->boff);//奇数场奇数即一帧图像采集结束，更换ccdc采集的数据存放地址
				}
				if (vpfe->mode_changed) {
					ccdc_setwin(&image_window,
						    frm_format, 2);
					/* update the field offset */
					vpfe->field_offset =
					    (vpfe->vwin.height -
					     2) * vpfe->vwin.width;
					vpfe->mode_changed = FALSE;
				}
			}
		} else if (fid == 0) {	/* even field */
			/* recover from any hardware out-of-sync due to */
			/* possible switch of video source              */
			/* for fid == 0, sync up the two fids           */
			/* for fid == 1, no action, one bad frame will  */
			/* go out, but it is not a big deal             */
			vpfe->field_id = fid;
		}
	} else if (frm_format == CCDC_FRMFMT_PROGRESSIVE) {

		dev_dbg(vpfe_dev, "\nframe format is progressive...");
		if (vpfe->curFrm != vpfe->nextFrm) {
			/* Copy frame capture time value in curFrm->ts */
			vpfe->curFrm->ts = timevalue;
			vpfe->curFrm->state = STATE_DONE;
			wake_up_interruptible(&vpfe->curFrm->done);
			vpfe->curFrm = vpfe->nextFrm;
		}

	}
	dev_dbg(vpfe_dev, "interrupt returned.\n");
	return IRQ_RETVAL(1);

依旧我对这段中断程序的理解来说，先是执行偶场产生的中断（一帧数据VPFE会产生一个中断，但是隔行扫描时会出现奇偶两场的中断）所以在中断程序中会出现if的判断。

比起逐行的模式复杂很多。在中断程序中，偶场先到，然后会判断当前视频的帧缓存区是不是和下一个是一样（在启动前已经将当前的curfrm=nextfrm)，在奇数场中断到来时，首先查看dma_queue链表是否为空并判断当前和下一个缓存区帧是否一样，如果一样，就获取链表中的缓存区buffer[1]给nextfrm，去除当前缓存区在dma_queue的位置。同时对下一帧数据在DDR中的存储地址进行修改。当当前帧完成，也就是一下针对偶场开始时，会发现nextfrm不等于curfrm(即第一个缓存区已经存储了第一帧数据），则把存储了第一帧数据的缓存区buffer[0]设置为STATE_DONE，随后curfrm=nextfrm=buffer[1]。以此循环进行。虽然我们会发现出现dma_queue中的内容消失了，也就是说缓存区都放好了数据之后，都不在该链表中。后来才发现还会再做入列操作。

4.VIDIOC_DQBUF命令

int
videobuf_dqbuf(struct videobuf_queue *q,
	       struct v4l2_buffer *b, int nonblocking)//nonblocking=0，缓存区出队列
{
	struct videobuf_buffer *buf;
	int retval;

	down(&q->lock);
	retval = -EBUSY;
	if (q->reading)
		goto done;
	retval = -EINVAL;
	if (b->type != q->type)
		goto done;
	if (list_empty(&q->stream)) 
		goto done;
	buf = list_entry(q->stream.next, struct videobuf_buffer, stream);//遍历查找下一个缓存区
	retval = videobuf_waiton(buf, nonblocking, 1);//阻塞处理
	if (retval < 0)
		goto done;
	switch (buf->state) {
	case STATE_ERROR:
		retval = -EIO;
		/* fall through */
	case STATE_DONE:
		if(q->pci)
			videobuf_dma_pci_sync(q->pci,&buf->dma);
		buf->state = STATE_IDLE;
		break;
	default:
		retval = -EINVAL;
		goto done;
	}
	list_del(&buf->stream);//从链表中去除当前buf的链表
	memset(b,0,sizeof(*b));
	videobuf_status(b,buf,q->type);

 done:
	up(&q->lock);
	return retval;
}

其实按照函数的执行流程，该函数应该先于中断函数执行，该函数先生遍历stream链表获取当前的缓存区这里理解为buffer[0]。然后进入写数据以阻塞的方式进行，启动等待队列，直到该进程被再次调度。而该等待队列的唤醒，恰恰在中断中进行，也就是一帧数据写入完成到buffer[0]时进行，同时在完成这一步之后，随后在应用程序中就会再次调用VIDIOC_QBUF这个命令，完成对当前以完成一帧数据存储的缓存区buffer[0]重新加入到dma_queue中，这就顺利解决了缓存区数据的循环写入。不会像之前理解的那样以为只有出列操作。总结就是，先启动后，缓存区出列操作，进入等待队列阻塞，直到完成一帧数据的写入哦，应用程序再对当前缓存区实现入列操作。故形成循环。

以上3篇博文都为自己阅读linux下面V4L2视频驱动架构下的源码所得，全部为自己总结。为整个项目的顺利进行打好基础。