#include <linux/kthread.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-ioctl.h>
-#include <media/videobuf-dma-contig.h>
+#include <media/videobuf2-dma-contig.h>
#include "dt3155v4l.h"
#define DT3155_BUF_SIZE (768 * 576)
+#ifdef CONFIG_DT3155_STREAMING
+#define DT3155_CAPTURE_METHOD V4L2_CAP_STREAMING
+#else
+#define DT3155_CAPTURE_METHOD V4L2_CAP_READWRITE
+#endif
+
/* global initializers (for all boards) */
#ifdef CONFIG_DT3155_CCIR
static const u8 csr2_init = VT_50HZ;
static int
dt3155_start_acq(struct dt3155_priv *pd)
{
- struct videobuf_buffer *vb = pd->curr_buf;
+ struct vb2_buffer *vb = pd->curr_buf;
dma_addr_t dma_addr;
- dma_addr = videobuf_to_dma_contig(vb);
+ dma_addr = vb2_dma_contig_plane_paddr(vb, 0);
iowrite32(dma_addr, pd->regs + EVEN_DMA_START);
- iowrite32(dma_addr + vb->width, pd->regs + ODD_DMA_START);
- iowrite32(vb->width, pd->regs + EVEN_DMA_STRIDE);
- iowrite32(vb->width, pd->regs + ODD_DMA_STRIDE);
+ iowrite32(dma_addr + img_width, pd->regs + ODD_DMA_START);
+ iowrite32(img_width, pd->regs + EVEN_DMA_STRIDE);
+ iowrite32(img_width, pd->regs + ODD_DMA_STRIDE);
/* enable interrupts, clear all irq flags */
iowrite32(FLD_START_EN | FLD_END_ODD_EN | FLD_START |
FLD_END_EVEN | FLD_END_ODD, pd->regs + INT_CSR);
return 0; /* success */
}
+/*
+ * driver-specific callbacks (vb2_ops)
+ */
static int
-dt3155_stop_acq(struct dt3155_priv *pd)
+dt3155_queue_setup(struct vb2_queue *q, unsigned int *num_buffers,
+ unsigned int *num_planes, unsigned long sizes[],
+ void *alloc_ctxs[])
{
- int tmp;
+ struct dt3155_priv *pd = vb2_get_drv_priv(q);
+ void *ret;
+
+ if (*num_buffers == 0)
+ *num_buffers = 1;
+ *num_planes = 1;
+ sizes[0] = img_width * img_height;
+ if (pd->q->alloc_ctx[0])
+ return 0;
+ ret = vb2_dma_contig_init_ctx(&pd->pdev->dev);
+ if (IS_ERR(ret))
+ return PTR_ERR(ret);
+ pd->q->alloc_ctx[0] = ret;
+ return 0;
+}
- /* stop the board */
- wait_i2c_reg(pd->regs);
- write_i2c_reg(pd->regs, CSR2, pd->csr2);
+static void
+dt3155_wait_prepare(struct vb2_queue *q)
+{
+ struct dt3155_priv *pd = vb2_get_drv_priv(q);
- /* disable all irqs, clear all irq flags */
- iowrite32(FLD_START | FLD_END_EVEN | FLD_END_ODD, pd->regs + INT_CSR);
- write_i2c_reg(pd->regs, EVEN_CSR, CSR_ERROR | CSR_DONE);
- write_i2c_reg(pd->regs, ODD_CSR, CSR_ERROR | CSR_DONE);
- tmp = ioread32(pd->regs + CSR1) & (FLD_CRPT_EVEN | FLD_CRPT_ODD);
- if (tmp)
- printk(KERN_ERR "dt3155: corrupted field %u\n", tmp);
- iowrite32(FIFO_EN | SRST | FLD_CRPT_ODD | FLD_CRPT_EVEN |
- FLD_DN_ODD | FLD_DN_EVEN | CAP_CONT_EVEN | CAP_CONT_ODD,
- pd->regs + CSR1);
- return 0;
+ mutex_unlock(pd->vdev->lock);
+}
+
+static void
+dt3155_wait_finish(struct vb2_queue *q)
+{
+ struct dt3155_priv *pd = vb2_get_drv_priv(q);
+
+ mutex_lock(pd->vdev->lock);
}
-/* Locking: Caller holds q->vb_lock */
static int
-dt3155_buf_setup(struct videobuf_queue *q, unsigned int *count,
- unsigned int *size)
+dt3155_buf_prepare(struct vb2_buffer *vb)
{
- *size = img_width * img_height;
+ vb2_set_plane_payload(vb, 0, img_width * img_height);
return 0;
}
-/* Locking: Caller holds q->vb_lock */
static int
-dt3155_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
- enum v4l2_field field)
+dt3155_start_streaming(struct vb2_queue *q)
{
- int ret = 0;
-
- vb->width = img_width;
- vb->height = img_height;
- vb->size = img_width * img_height;
- vb->field = field;
- if (vb->state == VIDEOBUF_NEEDS_INIT)
- ret = videobuf_iolock(q, vb, NULL);
- if (ret) {
- vb->state = VIDEOBUF_ERROR;
- printk(KERN_ERR "ERROR: videobuf_iolock() failed\n");
- videobuf_dma_contig_free(q, vb); /* FIXME: needed? */
- } else
- vb->state = VIDEOBUF_PREPARED;
- return ret;
+ return 0;
}
-/* Locking: Caller holds q->vb_lock & q->irqlock */
-static void
-dt3155_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
+static int
+dt3155_stop_streaming(struct vb2_queue *q)
{
- struct dt3155_priv *pd = q->priv_data;
-
- if (vb->state != VIDEOBUF_NEEDS_INIT) {
- vb->state = VIDEOBUF_QUEUED;
- list_add_tail(&vb->queue, &pd->dmaq);
- wake_up_interruptible_sync(&pd->do_dma);
- } else
- vb->state = VIDEOBUF_ERROR;
+ struct dt3155_priv *pd = vb2_get_drv_priv(q);
+ struct vb2_buffer *vb;
+
+ spin_lock_irq(&pd->lock);
+ while (!list_empty(&pd->dmaq)) {
+ vb = list_first_entry(&pd->dmaq, typeof(*vb), done_entry);
+ list_del(&vb->done_entry);
+ vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
+ }
+ spin_unlock_irq(&pd->lock);
+ msleep(45); /* irq hendler will stop the hardware */
+ return 0;
}
-/* Locking: Caller holds q->vb_lock */
static void
-dt3155_buf_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+dt3155_buf_queue(struct vb2_buffer *vb)
{
- if (vb->state == VIDEOBUF_ACTIVE)
- videobuf_waiton(q, vb, 0, 0); /* FIXME: cannot be interrupted */
- videobuf_dma_contig_free(q, vb);
- vb->state = VIDEOBUF_NEEDS_INIT;
+ struct dt3155_priv *pd = vb2_get_drv_priv(vb->vb2_queue);
+
+ /* pd->q->streaming = 1 when dt3155_buf_queue() is invoked */
+ spin_lock_irq(&pd->lock);
+ if (pd->curr_buf)
+ list_add_tail(&vb->done_entry, &pd->dmaq);
+ else {
+ pd->curr_buf = vb;
+ dt3155_start_acq(pd);
+ }
+ spin_unlock_irq(&pd->lock);
}
+/*
+ * end driver-specific callbacks
+ */
-static struct videobuf_queue_ops vbq_ops = {
- .buf_setup = dt3155_buf_setup,
+const struct vb2_ops q_ops = {
+ .queue_setup = dt3155_queue_setup,
+ .wait_prepare = dt3155_wait_prepare,
+ .wait_finish = dt3155_wait_finish,
.buf_prepare = dt3155_buf_prepare,
+ .start_streaming = dt3155_start_streaming,
+ .stop_streaming = dt3155_stop_streaming,
.buf_queue = dt3155_buf_queue,
- .buf_release = dt3155_buf_release,
};
static irqreturn_t
dt3155_irq_handler_even(int irq, void *dev_id)
{
struct dt3155_priv *ipd = dev_id;
- struct videobuf_buffer *ivb;
+ struct vb2_buffer *ivb;
dma_addr_t dma_addr;
u32 tmp;
}
spin_lock(&ipd->lock);
- if (ipd->curr_buf && ipd->curr_buf->state == VIDEOBUF_ACTIVE) {
- if (waitqueue_active(&ipd->curr_buf->done)) {
- do_gettimeofday(&ipd->curr_buf->ts);
- ipd->curr_buf->field_count = ipd->field_count;
- ipd->curr_buf->state = VIDEOBUF_DONE;
- wake_up(&ipd->curr_buf->done);
- } else {
- ivb = ipd->curr_buf;
- goto load_dma;
- }
- } else
- goto stop_dma;
- if (list_empty(&ipd->dmaq))
- goto stop_dma;
- ivb = list_first_entry(&ipd->dmaq, typeof(*ivb), queue);
- list_del(&ivb->queue);
- if (ivb->state == VIDEOBUF_QUEUED) {
- ivb->state = VIDEOBUF_ACTIVE;
- ipd->curr_buf = ivb;
- } else
+ if (ipd->curr_buf) {
+ do_gettimeofday(&ipd->curr_buf->v4l2_buf.timestamp);
+ ipd->curr_buf->v4l2_buf.sequence = (ipd->field_count) >> 1;
+ vb2_buffer_done(ipd->curr_buf, VB2_BUF_STATE_DONE);
+ }
+
+ if (!ipd->q->streaming || list_empty(&ipd->dmaq))
goto stop_dma;
-load_dma:
- dma_addr = videobuf_to_dma_contig(ivb);
+ ivb = list_first_entry(&ipd->dmaq, typeof(*ivb), done_entry);
+ list_del(&ivb->done_entry);
+ ipd->curr_buf = ivb;
+ dma_addr = vb2_dma_contig_plane_paddr(ivb, 0);
iowrite32(dma_addr, ipd->regs + EVEN_DMA_START);
- iowrite32(dma_addr + ivb->width, ipd->regs + ODD_DMA_START);
- iowrite32(ivb->width, ipd->regs + EVEN_DMA_STRIDE);
- iowrite32(ivb->width, ipd->regs + ODD_DMA_STRIDE);
+ iowrite32(dma_addr + img_width, ipd->regs + ODD_DMA_START);
+ iowrite32(img_width, ipd->regs + EVEN_DMA_STRIDE);
+ iowrite32(img_width, ipd->regs + ODD_DMA_STRIDE);
mmiowb();
/* enable interrupts, clear all irq flags */
iowrite32(FLD_START_EN | FLD_END_ODD_EN | FLD_START |
ipd->curr_buf = NULL;
/* stop the board */
write_i2c_reg_nowait(ipd->regs, CSR2, ipd->csr2);
+ iowrite32(FIFO_EN | SRST | FLD_CRPT_ODD | FLD_CRPT_EVEN |
+ FLD_DN_ODD | FLD_DN_EVEN, ipd->regs + CSR1);
/* disable interrupts, clear all irq flags */
iowrite32(FLD_START | FLD_END_EVEN | FLD_END_ODD, ipd->regs + INT_CSR);
spin_unlock(&ipd->lock);
return IRQ_HANDLED;
}
-static int
-dt3155_threadfn(void *arg)
-{
- struct dt3155_priv *pd = arg;
- struct videobuf_buffer *vb;
- unsigned long flags;
-
- while (1) {
- wait_event_interruptible(pd->do_dma,
- kthread_should_stop() || !list_empty(&pd->dmaq));
- if (kthread_should_stop())
- break;
-
- spin_lock_irqsave(&pd->lock, flags);
- if (pd->curr_buf) /* dma is active */
- goto done;
- if (list_empty(&pd->dmaq)) /* no empty biffers */
- goto done;
- vb = list_first_entry(&pd->dmaq, typeof(*vb), queue);
- list_del(&vb->queue);
- if (vb->state == VIDEOBUF_QUEUED) {
- vb->state = VIDEOBUF_ACTIVE;
- pd->curr_buf = vb;
- spin_unlock_irqrestore(&pd->lock, flags);
- /* start dma */
- dt3155_start_acq(pd);
- continue;
- } else
- printk(KERN_DEBUG "%s(): This is a BUG\n", __func__);
-done:
- spin_unlock_irqrestore(&pd->lock, flags);
- }
- return 0;
-}
-
static int
dt3155_open(struct file *filp)
{
int ret = 0;
struct dt3155_priv *pd = video_drvdata(filp);
- printk(KERN_INFO "dt3155: open(): minor: %i\n", pd->vdev->minor);
+ printk(KERN_INFO "dt3155: open(): minor: %i, users: %i\n",
+ pd->vdev->minor, pd->users);
- if (mutex_lock_interruptible(&pd->mux) == -EINTR)
- return -ERESTARTSYS;
if (!pd->users) {
- pd->vidq = kzalloc(sizeof(*pd->vidq), GFP_KERNEL);
- if (!pd->vidq) {
+ pd->q = kzalloc(sizeof(*pd->q), GFP_KERNEL);
+ if (!pd->q) {
printk(KERN_ERR "dt3155: error: alloc queue\n");
ret = -ENOMEM;
goto err_alloc_queue;
}
- videobuf_queue_dma_contig_init(pd->vidq, &vbq_ops,
- &pd->pdev->dev, &pd->lock,
- V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
- sizeof(struct videobuf_buffer), pd, NULL);
+ pd->q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ pd->q->io_modes = VB2_READ | VB2_MMAP;
+ pd->q->ops = &q_ops;
+ pd->q->mem_ops = &vb2_dma_contig_memops;
+ pd->q->drv_priv = pd;
+ pd->curr_buf = NULL;
+ pd->field_count = 0;
+ vb2_queue_init(pd->q); /* cannot fail */
+ INIT_LIST_HEAD(&pd->dmaq);
+ spin_lock_init(&pd->lock);
/* disable all irqs, clear all irq flags */
iowrite32(FLD_START | FLD_END_EVEN | FLD_END_ODD,
pd->regs + INT_CSR);
printk(KERN_ERR "dt3155: error: request_irq\n");
goto err_request_irq;
}
- pd->curr_buf = NULL;
- pd->thread = kthread_run(dt3155_threadfn, pd,
- "dt3155_thread_%i", pd->vdev->minor);
- if (IS_ERR(pd->thread)) {
- printk(KERN_ERR "dt3155: kthread_run() failed\n");
- ret = PTR_ERR(pd->thread);
- goto err_thread;
- }
- pd->field_count = 0;
}
pd->users++;
- goto done;
-err_thread:
- free_irq(pd->pdev->irq, pd);
+ return 0; /* success */
err_request_irq:
- kfree(pd->vidq);
- pd->vidq = NULL;
+ kfree(pd->q);
+ pd->q = NULL;
err_alloc_queue:
-done:
- mutex_unlock(&pd->mux);
return ret;
}
dt3155_release(struct file *filp)
{
struct dt3155_priv *pd = video_drvdata(filp);
- struct videobuf_buffer *tmp;
- unsigned long flags;
- int ret = 0;
- printk(KERN_INFO "dt3155: release(): minor: %i\n", pd->vdev->minor);
+ printk(KERN_INFO "dt3155: release(): minor: %i, users: %i\n",
+ pd->vdev->minor, pd->users - 1);
- if (mutex_lock_interruptible(&pd->mux) == -EINTR)
- return -ERESTARTSYS;
pd->users--;
BUG_ON(pd->users < 0);
- if (pd->acq_fp == filp) {
- spin_lock_irqsave(&pd->lock, flags);
- INIT_LIST_HEAD(&pd->dmaq); /* queue is emptied */
- tmp = pd->curr_buf;
- spin_unlock_irqrestore(&pd->lock, flags);
- if (tmp)
- videobuf_waiton(pd->vidq, tmp, 0, 1); /* block, interruptible */
- dt3155_stop_acq(pd);
- videobuf_stop(pd->vidq);
- pd->acq_fp = NULL;
- pd->streaming = 0;
- }
if (!pd->users) {
- kthread_stop(pd->thread);
+ vb2_queue_release(pd->q);
free_irq(pd->pdev->irq, pd);
- kfree(pd->vidq);
- pd->vidq = NULL;
+ if (pd->q->alloc_ctx[0])
+ vb2_dma_contig_cleanup_ctx(pd->q->alloc_ctx[0]);
+ kfree(pd->q);
+ pd->q = NULL;
}
- mutex_unlock(&pd->mux);
- return ret;
+ return 0;
}
static ssize_t
dt3155_read(struct file *filp, char __user *user, size_t size, loff_t *loff)
{
struct dt3155_priv *pd = video_drvdata(filp);
- int ret;
-
- if (mutex_lock_interruptible(&pd->mux) == -EINTR)
- return -ERESTARTSYS;
- if (!pd->acq_fp) {
- pd->acq_fp = filp;
- pd->streaming = 0;
- } else if (pd->acq_fp != filp) {
- ret = -EBUSY;
- goto done;
- } else if (pd->streaming == 1) {
- ret = -EINVAL;
- goto done;
- }
- ret = videobuf_read_stream(pd->vidq, user, size, loff, 0,
- filp->f_flags & O_NONBLOCK);
-done:
- mutex_unlock(&pd->mux);
- return ret;
+
+ return vb2_read(pd->q, user, size, loff, filp->f_flags & O_NONBLOCK);
}
static unsigned int
{
struct dt3155_priv *pd = video_drvdata(filp);
- return videobuf_poll_stream(filp, pd->vidq, polltbl);
+ return vb2_poll(pd->q, filp, polltbl);
}
static int
{
struct dt3155_priv *pd = video_drvdata(filp);
- return videobuf_mmap_mapper(pd->vidq, vma);
+ return vb2_mmap(pd->q, vma);
}
static const struct v4l2_file_operations dt3155_fops = {
dt3155_ioc_streamon(struct file *filp, void *p, enum v4l2_buf_type type)
{
struct dt3155_priv *pd = video_drvdata(filp);
- int ret = -ERESTARTSYS;
-
- if (mutex_lock_interruptible(&pd->mux) == -EINTR)
- return ret;
- if (!pd->acq_fp) {
- ret = videobuf_streamon(pd->vidq);
- if (ret)
- goto unlock;
- pd->acq_fp = filp;
- pd->streaming = 1;
- wake_up_interruptible_sync(&pd->do_dma);
- } else if (pd->acq_fp == filp) {
- pd->streaming = 1;
- ret = videobuf_streamon(pd->vidq);
- if (!ret)
- wake_up_interruptible_sync(&pd->do_dma);
- } else
- ret = -EBUSY;
-unlock:
- mutex_unlock(&pd->mux);
- return ret;
+
+ return vb2_streamon(pd->q, type);
}
static int
dt3155_ioc_streamoff(struct file *filp, void *p, enum v4l2_buf_type type)
{
struct dt3155_priv *pd = video_drvdata(filp);
- struct videobuf_buffer *tmp;
- unsigned long flags;
- int ret;
-
- ret = videobuf_streamoff(pd->vidq);
- if (ret)
- return ret;
- spin_lock_irqsave(&pd->lock, flags);
- tmp = pd->curr_buf;
- spin_unlock_irqrestore(&pd->lock, flags);
- if (tmp)
- videobuf_waiton(pd->vidq, tmp, 0, 1); /* block, interruptible */
- return ret;
+
+ return vb2_streamoff(pd->q, type);
}
static int
cap->version =
KERNEL_VERSION(DT3155_VER_MAJ, DT3155_VER_MIN, DT3155_VER_EXT);
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
- V4L2_CAP_STREAMING |
- V4L2_CAP_READWRITE;
+ DT3155_CAPTURE_METHOD;
return 0;
}
static int
dt3155_ioc_s_fmt_vid_cap(struct file *filp, void *p, struct v4l2_format *f)
{
- struct dt3155_priv *pd = video_drvdata(filp);
- int ret = -ERESTARTSYS;
-
- if (mutex_lock_interruptible(&pd->mux) == -EINTR)
- return ret;
- if (!pd->acq_fp) {
- pd->acq_fp = filp;
- pd->streaming = 0;
- } else if (pd->acq_fp != filp) {
- ret = -EBUSY;
- goto done;
- }
-/* FIXME: we don't change the format for now
- if (pd->vidq->streaming || pd->vidq->reading || pd->curr_buff) {
- ret = -EBUSY;
- goto done;
- }
-*/
- ret = dt3155_ioc_g_fmt_vid_cap(filp, p, f);
-done:
- mutex_unlock(&pd->mux);
- return ret;
+ return dt3155_ioc_g_fmt_vid_cap(filp, p, f);
}
static int
dt3155_ioc_reqbufs(struct file *filp, void *p, struct v4l2_requestbuffers *b)
{
struct dt3155_priv *pd = video_drvdata(filp);
- struct videobuf_queue *q = pd->vidq;
- int ret = -ERESTARTSYS;
- if (b->memory != V4L2_MEMORY_MMAP)
- return -EINVAL;
- if (mutex_lock_interruptible(&pd->mux) == -EINTR)
- return ret;
- if (!pd->acq_fp)
- pd->acq_fp = filp;
- else if (pd->acq_fp != filp) {
- ret = -EBUSY;
- goto done;
- }
- pd->streaming = 1;
- ret = 0;
-done:
- mutex_unlock(&pd->mux);
- if (ret)
- return ret;
- if (b->count)
- ret = videobuf_reqbufs(q, b);
- else { /* FIXME: is it necessary? */
- printk(KERN_DEBUG "dt3155: request to free buffers\n");
- /* ret = videobuf_mmap_free(q); */
- ret = dt3155_ioc_streamoff(filp, p,
- V4L2_BUF_TYPE_VIDEO_CAPTURE);
- }
- return ret;
+ return vb2_reqbufs(pd->q, b);
}
static int
dt3155_ioc_querybuf(struct file *filp, void *p, struct v4l2_buffer *b)
{
struct dt3155_priv *pd = video_drvdata(filp);
- struct videobuf_queue *q = pd->vidq;
- return videobuf_querybuf(q, b);
+ return vb2_querybuf(pd->q, b);
}
static int
dt3155_ioc_qbuf(struct file *filp, void *p, struct v4l2_buffer *b)
{
struct dt3155_priv *pd = video_drvdata(filp);
- struct videobuf_queue *q = pd->vidq;
- int ret;
- ret = videobuf_qbuf(q, b);
- if (ret)
- return ret;
- return videobuf_querybuf(q, b);
+ return vb2_qbuf(pd->q, b);
}
static int
dt3155_ioc_dqbuf(struct file *filp, void *p, struct v4l2_buffer *b)
{
struct dt3155_priv *pd = video_drvdata(filp);
- struct videobuf_queue *q = pd->vidq;
- return videobuf_dqbuf(q, b, filp->f_flags & O_NONBLOCK);
+ return vb2_dqbuf(pd->q, b, filp->f_flags & O_NONBLOCK);
}
static int
};
static int __devinit
-dt3155_init_board(struct pci_dev *dev)
+dt3155_init_board(struct pci_dev *pdev)
{
- struct dt3155_priv *pd = pci_get_drvdata(dev);
+ struct dt3155_priv *pd = pci_get_drvdata(pdev);
void *buf_cpu;
dma_addr_t buf_dma;
int i;
u8 tmp;
- pci_set_master(dev); /* dt3155 needs it */
+ pci_set_master(pdev); /* dt3155 needs it */
/* resetting the adapter */
iowrite32(FLD_CRPT_ODD | FLD_CRPT_EVEN | FLD_DN_ODD | FLD_DN_EVEN,
pd->regs + CSR1);
mmiowb();
- msleep(10);
+ msleep(20);
/* initializing adaper registers */
iowrite32(FIFO_EN | SRST, pd->regs + CSR1);
write_i2c_reg(pd->regs, AD_CMD, VIDEO_CNL_1 | SYNC_CNL_1 | SYNC_LVL_3);
/* allocate memory, and initialize the DMA machine */
- buf_cpu = dma_alloc_coherent(&dev->dev, DT3155_BUF_SIZE, &buf_dma,
+ buf_cpu = dma_alloc_coherent(&pdev->dev, DT3155_BUF_SIZE, &buf_dma,
GFP_KERNEL);
if (!buf_cpu) {
printk(KERN_ERR "dt3155: dma_alloc_coherent "
iowrite32(FIFO_EN | SRST | FLD_DN_EVEN | FLD_DN_ODD, pd->regs + CSR1);
/* deallocate memory */
- dma_free_coherent(&dev->dev, DT3155_BUF_SIZE, buf_cpu, buf_dma);
+ dma_free_coherent(&pdev->dev, DT3155_BUF_SIZE, buf_cpu, buf_dma);
if (tmp & BUSY_EVEN) {
printk(KERN_ERR "dt3155: BUSY_EVEN not cleared\n");
return -EIO;
/* same as in drivers/base/dma-coherent.c */
struct dma_coherent_mem {
void *virt_base;
- u32 device_base;
+ dma_addr_t device_base;
int size;
int flags;
unsigned long *bitmap;
}
static int __devinit
-dt3155_probe(struct pci_dev *dev, const struct pci_device_id *id)
+dt3155_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
int err;
struct dt3155_priv *pd;
printk(KERN_INFO "dt3155: probe()\n");
- err = dma_set_mask(&dev->dev, DMA_BIT_MASK(32));
+ err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
if (err) {
printk(KERN_ERR "dt3155: cannot set dma_mask\n");
return -ENODEV;
}
- err = dma_set_coherent_mask(&dev->dev, DMA_BIT_MASK(32));
+ err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
if (err) {
printk(KERN_ERR "dt3155: cannot set dma_coherent_mask\n");
return -ENODEV;
goto err_video_device_alloc;
}
*pd->vdev = dt3155_vdev;
- pci_set_drvdata(dev, pd); /* for use in dt3155_remove() */
+ pci_set_drvdata(pdev, pd); /* for use in dt3155_remove() */
video_set_drvdata(pd->vdev, pd); /* for use in video_fops */
pd->users = 0;
- pd->acq_fp = NULL;
- pd->pdev = dev;
+ pd->pdev = pdev;
INIT_LIST_HEAD(&pd->dmaq);
- init_waitqueue_head(&pd->do_dma);
mutex_init(&pd->mux);
+ pd->vdev->lock = &pd->mux; /* for locking v4l2_file_operations */
+ spin_lock_init(&pd->lock);
pd->csr2 = csr2_init;
pd->config = config_init;
- err = pci_enable_device(pd->pdev);
+ err = pci_enable_device(pdev);
if (err) {
printk(KERN_ERR "dt3155: pci_dev not enabled\n");
goto err_enable_dev;
}
- err = pci_request_region(pd->pdev, 0, pci_name(pd->pdev));
+ err = pci_request_region(pdev, 0, pci_name(pdev));
if (err)
goto err_req_region;
- pd->regs = pci_iomap(pd->pdev, 0, pci_resource_len(pd->pdev, 0));
+ pd->regs = pci_iomap(pdev, 0, pci_resource_len(pd->pdev, 0));
if (!pd->regs) {
err = -ENOMEM;
printk(KERN_ERR "dt3155: pci_iomap failed\n");
goto err_pci_iomap;
}
- err = dt3155_init_board(pd->pdev);
+ err = dt3155_init_board(pdev);
if (err) {
printk(KERN_ERR "dt3155: dt3155_init_board failed\n");
goto err_init_board;
printk(KERN_ERR "dt3155: Cannot register video device\n");
goto err_init_board;
}
- err = dt3155_alloc_coherent(&dev->dev, DT3155_CHUNK_SIZE,
+ err = dt3155_alloc_coherent(&pdev->dev, DT3155_CHUNK_SIZE,
DMA_MEMORY_MAP);
if (err)
printk(KERN_INFO "dt3155: preallocated 8 buffers\n");
return 0; /* success */
err_init_board:
- pci_iounmap(pd->pdev, pd->regs);
+ pci_iounmap(pdev, pd->regs);
err_pci_iomap:
- pci_release_region(pd->pdev, 0);
+ pci_release_region(pdev, 0);
err_req_region:
- pci_disable_device(pd->pdev);
+ pci_disable_device(pdev);
err_enable_dev:
video_device_release(pd->vdev);
err_video_device_alloc:
}
static void __devexit
-dt3155_remove(struct pci_dev *dev)
+dt3155_remove(struct pci_dev *pdev)
{
- struct dt3155_priv *pd = pci_get_drvdata(dev);
+ struct dt3155_priv *pd = pci_get_drvdata(pdev);
printk(KERN_INFO "dt3155: remove()\n");
- dt3155_free_coherent(&dev->dev);
+ dt3155_free_coherent(&pdev->dev);
video_unregister_device(pd->vdev);
- pci_iounmap(dev, pd->regs);
- pci_release_region(pd->pdev, 0);
- pci_disable_device(pd->pdev);
+ pci_iounmap(pdev, pd->regs);
+ pci_release_region(pdev, 0);
+ pci_disable_device(pdev);
/*
* video_device_release() is invoked automatically
* see: struct video_device dt3155_vdev
projects / GitHub / MotorolaMobilityLLC / kernel-slsi.git / commitdiff