自学教程：C++ videobuf_waiton函数代码示例

/** * @brief:  for ak_videobuf_release, free buffer if camera stopped. *  * @author: caolianming * @date: 2014-01-06 * @param [in] *vq: V4L2 buffer queue information structure * @param [in] *buf: ak camera drivers structure, include struct videobuf_buffer  */static void free_buffer(struct videobuf_queue *vq, struct ak_buffer *buf){	struct soc_camera_device *icd = vq->priv_data;	struct videobuf_buffer *vb = &buf->vb;	struct soc_camera_host *ici = to_soc_camera_host(icd->parent);	struct ak_camera_dev *pcdev = ici->priv;		isp_dbg("%s (vb=0x%p) buf[%d] 0x%08lx %d/n", 			__func__, vb, vb->i, vb->baddr, vb->bsize);		BUG_ON(in_interrupt());	/* This waits until this buffer is out of danger, i.e., until it is no	 * longer in STATE_QUEUED or STATE_ACTIVE */	if (vb->state == VIDEOBUF_ACTIVE && !pcdev->dma_running) {		printk("free_buffer: dma_running=%d, doesn't neee to wait/n", pcdev->dma_running);		//vb->state = VIDEOBUF_ERROR;		list_del(&vb->queue);	} else {		vb->state = VIDEOBUF_DONE;		videobuf_waiton(vq, vb, 0, 0);	}	videobuf_dma_contig_free(vq, vb);	vb->state = VIDEOBUF_NEEDS_INIT;}

void cx18_dma_free(struct videobuf_queue *q,	struct cx18_stream *s, struct cx18_videobuf_buffer *buf){	videobuf_waiton(q, &buf->vb, 0, 0);	videobuf_vmalloc_free(&buf->vb);	buf->vb.state = VIDEOBUF_NEEDS_INIT;}

static voidcamera_core_vbq_release(struct videobuf_queue *q, struct videobuf_buffer *vb){    videobuf_waiton(vb, 0, 0);    videobuf_dma_pci_unmap(NULL, &vb->dma);    videobuf_dma_free(&vb->dma);    vb->state = STATE_NEEDS_INIT;}

void saa7134_dma_free(struct videobuf_queue *q,struct saa7134_buf *buf){	BUG_ON(in_interrupt());	videobuf_waiton(&buf->vb,0,0);	videobuf_dma_unmap(q, &buf->vb.dma);	videobuf_dma_free(&buf->vb.dma);	buf->vb.state = STATE_NEEDS_INIT;}

void saa7134_dma_free(struct videobuf_queue *q,struct saa7134_buf *buf){	struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);	BUG_ON(in_interrupt());	videobuf_waiton(&buf->vb,0,0);	videobuf_dma_unmap(q, dma);	videobuf_dma_free(dma);	buf->vb.state = VIDEOBUF_NEEDS_INIT;}

void saa7134_dma_free(struct saa7134_dev *dev,struct saa7134_buf *buf){	if (in_interrupt())		BUG();	videobuf_waiton(&buf->vb,0,0);	videobuf_dma_pci_unmap(dev->pci, &buf->vb.dma);	videobuf_dma_free(&buf->vb.dma);	buf->vb.state = STATE_NEEDS_INIT;}

int videobuf_dqbuf(struct videobuf_queue *q,	       struct v4l2_buffer *b, int nonblocking){	struct videobuf_buffer *buf;	int retval;	MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS);	mutex_lock(&q->lock);	retval = -EBUSY;	if (q->reading) {		dprintk(1,"dqbuf: Reading running.../n");		goto done;	}	retval = -EINVAL;	if (b->type != q->type) {		dprintk(1,"dqbuf: Wrong type./n");		goto done;	}	if (list_empty(&q->stream)) {		dprintk(1,"dqbuf: stream running/n");		goto done;	}	buf = list_entry(q->stream.next, struct videobuf_buffer, stream);	retval = videobuf_waiton(buf, nonblocking, 1);	if (retval < 0) {		dprintk(1,"dqbuf: waiton returned %d/n",retval);		goto done;	}	switch (buf->state) {	case STATE_ERROR:		dprintk(1,"dqbuf: state is error/n");		retval = -EIO;		CALL(q,sync,q, buf);		buf->state = STATE_IDLE;		break;	case STATE_DONE:		dprintk(1,"dqbuf: state is done/n");		CALL(q,sync,q, buf);		buf->state = STATE_IDLE;		break;	default:		dprintk(1,"dqbuf: state invalid/n");		retval = -EINVAL;		goto done;	}	list_del(&buf->stream);	memset(b,0,sizeof(*b));	videobuf_status(q,b,buf,q->type); done:	mutex_unlock(&q->lock);	return retval;}

void saa7146_dma_free(struct saa7146_dev *dev,struct saa7146_buf *buf){	DEB_EE(("dev:%p, buf:%p/n",dev,buf));	if (in_interrupt())		BUG();	videobuf_waiton(&buf->vb,0,0);	videobuf_dma_pci_unmap(dev->pci, &buf->vb.dma);	videobuf_dma_free(&buf->vb.dma);	buf->vb.state = STATE_NEEDS_INIT;}

void saa7146_dma_free(struct saa7146_dev *dev,struct videobuf_queue *q,						struct saa7146_buf *buf){	struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);	DEB_EE(("dev:%p, buf:%p/n",dev,buf));	BUG_ON(in_interrupt());	videobuf_waiton(&buf->vb,0,0);	videobuf_dma_unmap(q, dma);	videobuf_dma_free(dma);	buf->vb.state = VIDEOBUF_NEEDS_INIT;}

void tw68_dma_free(struct videobuf_queue *q, struct tw68_buf *buf){	struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);		if (core_debug & DBG_FLOW)		printk(KERN_DEBUG "%s: called/n", __func__);	BUG_ON(in_interrupt());#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,36)	videobuf_waiton(&buf->vb, 0, 0);#else	videobuf_waiton(q, &buf->vb, 0, 0);#endif#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,35)		videobuf_dma_unmap(q, dma);#else	videobuf_dma_unmap(q->dev, dma);#endif	videobuf_dma_free(dma);	/* if no risc area allocated, btcx_riscmem_free just returns */	btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);	buf->vb.state = VIDEOBUF_NEEDS_INIT;}

static int videobuf_dvb_thread(void *data){	struct videobuf_dvb *dvb = data;	struct videobuf_buffer *buf;	unsigned long flags;	int err;	void *outp;	dprintk("dvb thread started/n");	set_freezable();	videobuf_read_start(&dvb->dvbq);	for (;;) {		/* fetch next buffer */		buf = list_entry(dvb->dvbq.stream.next,				 struct videobuf_buffer, stream);		list_del(&buf->stream);		err = videobuf_waiton(buf,0,1);		/* no more feeds left or stop_feed() asked us to quit */		if (0 == dvb->nfeeds)			break;		if (kthread_should_stop())			break;		try_to_freeze();		/* feed buffer data to demux */		outp = videobuf_queue_to_vmalloc (&dvb->dvbq, buf);		if (buf->state == VIDEOBUF_DONE)			dvb_dmx_swfilter(&dvb->demux, outp,					 buf->size);		/* requeue buffer */		list_add_tail(&buf->stream,&dvb->dvbq.stream);		spin_lock_irqsave(dvb->dvbq.irqlock,flags);		dvb->dvbq.ops->buf_queue(&dvb->dvbq,buf);		spin_unlock_irqrestore(dvb->dvbq.irqlock,flags);	}	videobuf_read_stop(&dvb->dvbq);	dprintk("dvb thread stopped/n");	/* Hmm, linux becomes *very* unhappy without this ... */	while (!kthread_should_stop()) {		set_current_state(TASK_INTERRUPTIBLE);		schedule();	}	return 0;}

static void free_buffer(struct videobuf_queue *vq, struct mx1_buffer *buf){	struct soc_camera_device *icd = vq->priv_data;	struct videobuf_buffer *vb = &buf->vb;	BUG_ON(in_interrupt());	dev_dbg(icd->parent, "%s (vb=0x%p) 0x%08lx %d/n", __func__,		vb, vb->baddr, vb->bsize);	videobuf_waiton(vq, vb, 0, 0);	videobuf_dma_contig_free(vq, vb);	vb->state = VIDEOBUF_NEEDS_INIT;}

static void free_buffer(struct videobuf_queue *vq,			struct sh_mobile_ceu_buffer *buf){	struct soc_camera_device *icd = vq->priv_data;	dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd/n", __func__,		&buf->vb, buf->vb.baddr, buf->vb.bsize);	if (in_interrupt())		BUG();	videobuf_waiton(&buf->vb, 0, 0);	videobuf_dma_contig_free(vq, &buf->vb);	dev_dbg(&icd->dev, "%s freed/n", __func__);	buf->vb.state = VIDEOBUF_NEEDS_INIT;}

/* Locking: Caller holds q->lock */static ssize_t videobuf_read_zerocopy(struct videobuf_queue *q,				      char __user *data,				      size_t count, loff_t *ppos){	enum v4l2_field field;	unsigned long flags=0;	int retval;	MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS);	/* setup stuff */	q->read_buf = videobuf_alloc(q);	if (NULL == q->read_buf)		return -ENOMEM;	q->read_buf->memory = V4L2_MEMORY_USERPTR;	q->read_buf->baddr  = (unsigned long)data;	q->read_buf->bsize  = count;	field = videobuf_next_field(q);	retval = q->ops->buf_prepare(q,q->read_buf,field);	if (0 != retval)		goto done;	/* start capture & wait */	if (q->irqlock)		spin_lock_irqsave(q->irqlock,flags);	q->ops->buf_queue(q,q->read_buf);	if (q->irqlock)		spin_unlock_irqrestore(q->irqlock,flags);	retval = videobuf_waiton(q->read_buf,0,0);	if (0 == retval) {		CALL(q,sync,q,q->read_buf);		if (STATE_ERROR == q->read_buf->state)			retval = -EIO;		else			retval = q->read_buf->size;	} done:	/* cleanup */	q->ops->buf_release(q,q->read_buf);	kfree(q->read_buf);	q->read_buf = NULL;	return retval;}

static void free_buffer(struct videobuf_queue *vq, struct jz4780_buffer *buf){	struct videobuf_buffer *vb = &buf->vb;	BUG_ON(in_interrupt());	dprintk(7, "%s (vb=0x%p) 0x%08lx %d/n", __func__,		vb, vb->baddr, vb->bsize);	/*	 * This waits until this buffer is out of danger, i.e., until it is no	 * longer in STATE_QUEUED or STATE_ACTIVE	 */	videobuf_waiton(vq, vb, 0, 0);	videobuf_dma_contig_free(vq, vb);	vb->state = VIDEOBUF_NEEDS_INIT;}

static void omap24xxcam_vbq_release(struct videobuf_queue *vbq,				    struct videobuf_buffer *vb){	struct videobuf_dmabuf *dma = videobuf_to_dma(vb);	/* wait for buffer, especially to get out of the sgdma queue */	videobuf_waiton(vbq, vb, 0, 0);	if (vb->memory == V4L2_MEMORY_MMAP) {		dma_unmap_sg(vbq->dev, dma->sglist, dma->sglen,			     dma->direction);		dma->direction = DMA_NONE;	} else {		videobuf_dma_unmap(vbq->dev, videobuf_to_dma(vb));		videobuf_dma_free(videobuf_to_dma(vb));	}	vb->state = VIDEOBUF_NEEDS_INIT;}

static void usbcam_videobuf_free(struct videobuf_queue *vq,				 struct usbcam_frame *framep){	struct videobuf_dmabuf *dma = usbframe_get_dmabuf(&framep->vbb);		videobuf_waiton(&framep->vbb, 0, 0);	videobuf_dma_unmap(vq, dma);	videobuf_dma_free(dma);	if (framep->vbb.state != STATE_NEEDS_INIT) {		if (framep->vmap_base) {			vunmap(framep->vmap_base);			framep->vmap_base = NULL;			framep->vmap_sof = NULL;		}		assert(list_empty(&framep->cap_links));		framep->vbb.state = STATE_NEEDS_INIT;	}}

static void free_buffer(struct videobuf_queue *vq, struct mx1_buffer *buf){	struct soc_camera_device *icd = vq->priv_data;	struct videobuf_buffer *vb = &buf->vb;	BUG_ON(in_interrupt());	dev_dbg(icd->parent, "%s (vb=0x%p) 0x%08lx %d/n", __func__,		vb, vb->baddr, vb->bsize);	/*	 * This waits until this buffer is out of danger, i.e., until it is no	 * longer in STATE_QUEUED or STATE_ACTIVE	 */	videobuf_waiton(vq, vb, 0, 0);	videobuf_dma_contig_free(vq, vb);	vb->state = VIDEOBUF_NEEDS_INIT;}

/* Locking: Caller holds q->vb_lock */static int stream_next_buffer(struct videobuf_queue *q,			struct videobuf_buffer **vb, int nonblocking){	int retval;	struct videobuf_buffer *buf = NULL;	retval = stream_next_buffer_check_queue(q, nonblocking);	if (retval)		goto done;	buf = list_entry(q->stream.next, struct videobuf_buffer, stream);	retval = videobuf_waiton(q, buf, nonblocking, 1);	if (retval < 0)		goto done;	*vb = buf;done:	return retval;}

static void free_buffer(struct videobuf_queue *vq, struct omap1_cam_buf *buf,		enum omap1_cam_vb_mode vb_mode){	struct videobuf_buffer *vb = &buf->vb;	BUG_ON(in_interrupt());	videobuf_waiton(vq, vb, 0, 0);	if (vb_mode == OMAP1_CAM_DMA_CONTIG) {		videobuf_dma_contig_free(vq, vb);	} else {		struct soc_camera_device *icd = vq->priv_data;		struct device *dev = icd->dev.parent;		struct videobuf_dmabuf *dma = videobuf_to_dma(vb);		videobuf_dma_unmap(dev, dma);		videobuf_dma_free(dma);	}	vb->state = VIDEOBUF_NEEDS_INIT;}

ssize_t videobuf_read_stream(struct videobuf_queue *q,			     char __user *data, size_t count, loff_t *ppos,			     int vbihack, int nonblocking){	int rc, retval;	unsigned long flags=0;	MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS);	dprintk(2,"%s/n",__FUNCTION__);	mutex_lock(&q->lock);	retval = -EBUSY;	if (q->streaming)		goto done;	if (!q->reading) {		retval = __videobuf_read_start(q);		if (retval < 0)			goto done;	}	retval = 0;	while (count > 0) {		/* get / wait for data */		if (NULL == q->read_buf) {			q->read_buf = list_entry(q->stream.next,						 struct videobuf_buffer,						 stream);			list_del(&q->read_buf->stream);			q->read_off = 0;		}		rc = videobuf_waiton(q->read_buf, nonblocking, 1);		if (rc < 0) {			if (0 == retval)				retval = rc;			break;		}		if (q->read_buf->state == STATE_DONE) {			rc = CALL (q,copy_stream, q, data + retval, count,					retval, vbihack, nonblocking);			if (rc < 0) {				retval = rc;				break;			}			retval      += rc;			count       -= rc;			q->read_off += rc;		} else {			/* some error */			q->read_off = q->read_buf->size;			if (0 == retval)				retval = -EIO;		}		/* requeue buffer when done with copying */		if (q->read_off == q->read_buf->size) {			list_add_tail(&q->read_buf->stream,				      &q->stream);			if (q->irqlock)				spin_lock_irqsave(q->irqlock,flags);			q->ops->buf_queue(q,q->read_buf);			if (q->irqlock)				spin_unlock_irqrestore(q->irqlock,flags);			q->read_buf = NULL;		}		if (retval < 0)			break;	}

ssize_t videobuf_read_one(struct videobuf_queue *q,			  char __user *data, size_t count, loff_t *ppos,			  int nonblocking){	enum v4l2_field field;	unsigned long flags=0;	unsigned size, nbufs;	int retval;	MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS);	mutex_lock(&q->lock);	nbufs = 1; size = 0;	q->ops->buf_setup(q,&nbufs,&size);	if (NULL == q->read_buf  &&	    count >= size        &&	    !nonblocking) {		retval = videobuf_read_zerocopy(q,data,count,ppos);		if (retval >= 0  ||  retval == -EIO)			/* ok, all done */			goto done;		/* fallback to kernel bounce buffer on failures */	}	if (NULL == q->read_buf) {		/* need to capture a new frame */		retval = -ENOMEM;		q->read_buf = videobuf_alloc(q);		dprintk(1,"video alloc=0x%p/n", q->read_buf);		if (NULL == q->read_buf)			goto done;		q->read_buf->memory = V4L2_MEMORY_USERPTR;		q->read_buf->bsize = count; /* preferred size */		field = videobuf_next_field(q);		retval = q->ops->buf_prepare(q,q->read_buf,field);		if (0 != retval) {			kfree (q->read_buf);			q->read_buf = NULL;			goto done;		}		if (q->irqlock)			spin_lock_irqsave(q->irqlock,flags);		q->ops->buf_queue(q,q->read_buf);		if (q->irqlock)			spin_unlock_irqrestore(q->irqlock,flags);		q->read_off = 0;	}	/* wait until capture is done */	retval = videobuf_waiton(q->read_buf, nonblocking, 1);	if (0 != retval)		goto done;	CALL(q,sync,q,q->read_buf);	if (STATE_ERROR == q->read_buf->state) {		/* catch I/O errors */		q->ops->buf_release(q,q->read_buf);		kfree(q->read_buf);		q->read_buf = NULL;		retval = -EIO;		goto done;	}	/* Copy to userspace */	retval=CALL(q,video_copy_to_user,q,data,count,nonblocking);	if (retval<0)		goto done;	q->read_off += retval;	if (q->read_off == q->read_buf->size) {		/* all data copied, cleanup */		q->ops->buf_release(q,q->read_buf);		kfree(q->read_buf);		q->read_buf = NULL;	} done:	mutex_unlock(&q->lock);	return retval;}