V4L2: Added Timberdale Logiwin driver

V4L2 video capture driver for the logiwin IP on the Timberdale FPGA.

The driver uses the Timberdale DMA engine

Signed-off-by Richard Röjfors <[email protected]>

---
Index: linux-2.6.30-rc7/drivers/media/video/timblogiw.c
===================================================================

drivers/media/video/timblogiw.c    (revision 867) renamed from drivers/media/video/timblogiw.c    (revision 0) +175 -0

@@ -0,0 +1,949 @@
+/*
+ * timblogiw.c timberdale FPGA LogiWin Video In driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA LogiWin Video In
+ */
+
+#include <linux/list.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
+#include <media/v4l2-device.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include "timblogiw.h"
+#include <linux/mfd/timbdma.h>
+#include <linux/i2c.h>
+#include <media/timb_video.h>
+
+#define TIMBLOGIW_CTRL 0x40
+
+#define TIMBLOGIW_H_SCALE 0x20
+#define TIMBLOGIW_V_SCALE 0x28
+
+#define TIMBLOGIW_X_CROP 0x58
+#define TIMBLOGIW_Y_CROP 0x60
+
+#define TIMBLOGIW_W_CROP 0x00
+#define TIMBLOGIW_H_CROP 0x08
+
+#define TIMBLOGIW_VERSION_CODE 0x02
+
+#define TIMBLOGIW_BUF  0x04
+#define TIMBLOGIW_TBI  0x2c
+#define TIMBLOGIW_BPL  0x30
+
+#define dbg(...)
+
+#define DMA_BUFFER_SIZE (720 * 576 * 2)
+
+const struct timblogiw_tvnorm timblogiw_tvnorms[] = {
+       {
+               .std                    = V4L2_STD_PAL,
+               .name                   = "PAL",
+               .width                  = 720,
+               .height                 = 576
+       },
+       {
+               .std                    = V4L2_STD_NTSC_M,
+               .name                   = "NTSC",
+               .width                  = 720,
+               .height                 = 480
+       }
+};
+
+static int timblogiw_bytes_per_line(const struct timblogiw_tvnorm *norm)
+{
+       return norm->width * 2;
+}
+
+
+static int timblogiw_frame_size(const struct timblogiw_tvnorm *norm)
+{
+       return norm->height * timblogiw_bytes_per_line(norm);
+}
+
+static const struct timblogiw_tvnorm *timblogiw_get_norm(const v4l2_std_id std)
+{
+       int i;
+       for (i = 0; i < ARRAY_SIZE(timblogiw_tvnorms); i++)
+               if (timblogiw_tvnorms[i].std == std)
+                       return timblogiw_tvnorms + i;
+
+       /* default to first element */
+       return timblogiw_tvnorms;
+}
+
+static void timblogiw_handleframe(unsigned long arg)
+{
+       struct timblogiw_frame *f;
+       struct timblogiw *lw = (struct timblogiw *)arg;
+
+       spin_lock_bh(&lw->queue_lock);
+       if (lw->dma.filled && !list_empty(&lw->inqueue)) {
+               /* put the entry in the outqueue */
+               f = list_entry(lw->inqueue.next, struct timblogiw_frame, frame);
+
+               /* copy data from the DMA buffer */
+               memcpy(f->bufmem, lw->dma.filled->buf, f->buf.length);
+               /* buffer consumed */
+               lw->dma.filled = NULL;
+
+               do_gettimeofday(&f->buf.timestamp);
+               f->buf.sequence = ++lw->frame_count;
+               f->buf.field = V4L2_FIELD_NONE;
+               f->state = F_DONE;
+               f->buf.bytesused = f->buf.length;
+               list_move_tail(&f->frame, &lw->outqueue);
+               /* wake up any waiter */
+               wake_up(&lw->wait_frame);
+       } else {
+               /* No user buffer available, consume buffer anyway
+                * who wants an old video frame?
+                */
+               lw->dma.filled = NULL;
+       }
+       spin_unlock_bh(&lw->queue_lock);
+}
+
+static int timblogiw_isr(u32 flag, void *pdev)
+{
+       struct timblogiw *lw = (struct timblogiw *)pdev;
+
+       if (!lw->dma.filled && (flag & DMA_IRQ_VIDEO_RX)) {
+               /* Got a frame, store it, and flip to next DMA buffer */
+               lw->dma.filled = lw->dma.transfer + lw->dma.curr;
+               lw->dma.curr = !lw->dma.curr;
+       }
+
+       if (lw->stream == STREAM_ON)
+               timb_start_dma(DMA_IRQ_VIDEO_RX,
+                       lw->dma.transfer[lw->dma.curr].handle,
+                       timblogiw_frame_size(lw->cur_norm),
+                       timblogiw_bytes_per_line(lw->cur_norm));
+
+       if (flag & DMA_IRQ_VIDEO_DROP)
+               dbg("%s: frame dropped\n", __func__);
+       if (flag & DMA_IRQ_VIDEO_RX) {
+               dbg("%s: frame RX\n", __func__);
+               tasklet_schedule(&lw->tasklet);
+       }
+       return 0;
+}
+
+static void timblogiw_empty_framequeues(struct timblogiw *lw)
+{
+       u32 i;
+
+       dbg("%s\n", __func__);
+
+       INIT_LIST_HEAD(&lw->inqueue);
+       INIT_LIST_HEAD(&lw->outqueue);
+
+       for (i = 0; i < lw->num_frames; i++) {
+               lw->frame[i].state = F_UNUSED;
+               lw->frame[i].buf.bytesused = 0;
+       }
+}
+
+u32 timblogiw_request_buffers(struct timblogiw *lw, u32 count)
+{
+       /* needs to be page aligned cause the */
+       /* buffers can be mapped individually! */
+       const size_t imagesize = PAGE_ALIGN(timblogiw_frame_size(lw->cur_norm));
+       void *buff = NULL;
+       u32 i;
+

drivers/media/video/timblogiw.c    (revision 867) renamed from drivers/media/video/timblogiw.c    (revision 0) +608 -0

+               if (lw->dma.transfer[0].buf != NULL)
+                       pci_free_consistent(lw->dev, DMA_BUFFER_SIZE,
+                               lw->dma.transfer[0].buf,
+                               lw->dma.transfer[0].handle);
+               if (lw->dma.transfer[1].buf != NULL)
+                       pci_free_consistent(lw->dev, DMA_BUFFER_SIZE,
+                               lw->dma.transfer[1].buf,
+                               lw->dma.transfer[1].handle);
+               return 0;
+       }
+
+       if (count > TIMBLOGIW_NUM_FRAMES)
+               count = TIMBLOGIW_NUM_FRAMES;
+
+       lw->num_frames = count;
+       while (lw->num_frames > 0) {
+               buff = vmalloc_32(lw->num_frames * imagesize);
+               if (buff) {
+                       memset(buff, 0, lw->num_frames * imagesize);
+                       break;
+               }
+               lw->num_frames--;
+       }
+
+       for (i = 0; i < lw->num_frames; i++) {
+               lw->frame[i].bufmem = buff + i * imagesize;
+               lw->frame[i].buf.index = i;
+               lw->frame[i].buf.m.offset = i * imagesize;
+               lw->frame[i].buf.length = timblogiw_frame_size(lw->cur_norm);
+               lw->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+               lw->frame[i].buf.sequence = 0;
+               lw->frame[i].buf.field = V4L2_FIELD_NONE;
+               lw->frame[i].buf.memory = V4L2_MEMORY_MMAP;
+               lw->frame[i].buf.flags = 0;
+       }
+
+       lw->dma.curr = 0;
+       lw->dma.filled = NULL;
+       return lw->num_frames;
+}
+
+void timblogiw_release_buffers(struct timblogiw *lw)
+{
+       dbg("%s\n", __func__);
+
+       if (lw->frame[0].bufmem != NULL) {
+               vfree(lw->frame[0].bufmem);
+               lw->frame[0].bufmem = NULL;
+               lw->num_frames = TIMBLOGIW_NUM_FRAMES;
+               pci_free_consistent(lw->dev, DMA_BUFFER_SIZE,
+                       lw->dma.transfer[0].buf, lw->dma.transfer[0].handle);
+               pci_free_consistent(lw->dev, DMA_BUFFER_SIZE,
+                       lw->dma.transfer[1].buf, lw->dma.transfer[1].handle);
+       }
+}
+
+/* IOCTL functions */
+
+static int timblogiw_g_fmt(struct file *file, void  *priv,
+       struct v4l2_format *format)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       format->fmt.pix.width = lw->cur_norm->width;
+       format->fmt.pix.height = lw->cur_norm->height;
+       format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
+       format->fmt.pix.bytesperline = timblogiw_bytes_per_line(lw->cur_norm);
+       format->fmt.pix.sizeimage = timblogiw_frame_size(lw->cur_norm);
+       format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
+       format->fmt.pix.field = V4L2_FIELD_NONE;
+       return 0;
+}
+
+static int timblogiw_try_fmt(struct file *file, void  *priv,
+       struct v4l2_format *format)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+       struct v4l2_pix_format *pix = &format->fmt.pix;
+
+       dbg("%s - width=%d, height=%d, pixelformat=%d, field=%d\n"
+               "bytes per line %d, size image: %d, colorspace: %d\n",
+               __func__,
+               pix->width, pix->height, pix->pixelformat, pix->field,
+               pix->bytesperline, pix->sizeimage, pix->colorspace);
+
+       if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       if (format->fmt.pix.field != V4L2_FIELD_NONE)
+               return -EINVAL;
+
+       if ((lw->cur_norm->height != pix->height) ||
+               (lw->cur_norm->width != pix->width)) {
+               pix->width = lw->cur_norm->width;
+               pix->height = lw->cur_norm->height;
+       }
+
+       return 0;
+}
+
+static int timblogiw_querycap(struct file *file, void  *priv,
+       struct v4l2_capability *cap)
+{
+       dbg("%s\n",  __func__);
+       memset(cap, 0, sizeof(*cap));
+       strncpy(cap->card, "Timberdale Video", sizeof(cap->card)-1);
+       strncpy(cap->driver, "Timblogiw", sizeof(cap->card)-1);
+       cap->version = TIMBLOGIW_VERSION_CODE;
+       cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+               V4L2_CAP_STREAMING;
+
+       return 0;
+}
+
+static int timblogiw_enum_fmt(struct file *file, void  *priv,
+       struct v4l2_fmtdesc *fmt)
+{
+       dbg("%s, index: %d\n",  __func__, fmt->index);
+
+       if (fmt->index != 0)
+               return -EINVAL;
+       memset(fmt, 0, sizeof(*fmt));
+       fmt->index = 0;
+       fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       strncpy(fmt->description, "4:2:2, packed, YUYV",
+               sizeof(fmt->description)-1);
+       fmt->pixelformat = V4L2_PIX_FMT_YUYV;
+       memset(fmt->reserved, 0, sizeof(fmt->reserved));
+
+       return 0;
+}
+
+static int timblogiw_reqbufs(struct file *file, void  *priv,
+       struct v4l2_requestbuffers *rb)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+               rb->memory != V4L2_MEMORY_MMAP)
+               return -EINVAL;
+
+       timblogiw_empty_framequeues(lw);
+
+       timblogiw_release_buffers(lw);
+       if (rb->count)
+               rb->count = timblogiw_request_buffers(lw, rb->count);
+
+       dbg("%s - VIDIOC_REQBUFS: io method is mmap. num bufs %i\n",
+               __func__, rb->count);
+
+       return 0;
+}
+
+static int timblogiw_querybuf(struct file *file, void  *priv,
+       struct v4l2_buffer *b)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+               b->index >= lw->num_frames)
+               return -EINVAL;
+
+       memcpy(b, &lw->frame[b->index].buf, sizeof(*b));
+
+       if (lw->frame[b->index].vma_use_count)
+               b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+       if (lw->frame[b->index].state == F_DONE)
+               b->flags |= V4L2_BUF_FLAG_DONE;
+       else if (lw->frame[b->index].state != F_UNUSED)
+               b->flags |= V4L2_BUF_FLAG_QUEUED;
+
+       return 0;
+}
+
+static int timblogiw_qbuf(struct file *file, void  *priv, struct v4l2_buffer *b)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+       unsigned long lock_flags;
+
+       if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+               b->index >= lw->num_frames)
+               return -EINVAL;
+
+       if (lw->frame[b->index].state != F_UNUSED)
+               return -EAGAIN;
+
+       if (b->memory != V4L2_MEMORY_MMAP)
+               return -EINVAL;
+
+       lw->frame[b->index].state = F_QUEUED;
+
+       spin_lock_irqsave(&lw->queue_lock, lock_flags);
+       list_add_tail(&lw->frame[b->index].frame, &lw->inqueue);
+       spin_unlock_irqrestore(&lw->queue_lock, lock_flags);
+
+       return 0;
+}
+
+static int timblogiw_dqbuf(struct file *file, void  *priv,
+       struct v4l2_buffer *b)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+       struct timblogiw_frame *f;
+       unsigned long lock_flags;
+       int ret = 0;
+
+       if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+               dbg("%s - VIDIOC_DQBUF, illegal buf type!\n",
+                       __func__);
+               return -EINVAL;
+       }
+
+       if (list_empty(&lw->outqueue)) {
+               if (file->f_flags & O_NONBLOCK)
+                       return -EAGAIN;
+
+               ret = wait_event_interruptible(lw->wait_frame,
+                       !list_empty(&lw->outqueue));
+               if (ret)
+                       return ret;
+       }
+
+       spin_lock_irqsave(&lw->queue_lock, lock_flags);
+       f = list_entry(lw->outqueue.next,
+                       struct timblogiw_frame, frame);
+       list_del(lw->outqueue.next);
+       spin_unlock_irqrestore(&lw->queue_lock, lock_flags);
+
+       f->state = F_UNUSED;
+       memcpy(b, &f->buf, sizeof(*b));
+
+       if (f->vma_use_count)
+               b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+       return 0;
+}
+
+static int timblogiw_g_std(struct file *file, void  *priv, v4l2_std_id *std)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       *std = lw->cur_norm->std;
+       return 0;
+}
+
+static int timblogiw_s_std(struct file *file, void  *priv, v4l2_std_id *std)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       if (!(*std & lw->cur_norm->std))
+               return -EINVAL;
+       return 0;
+}
+
+static int timblogiw_enuminput(struct file *file, void  *priv,
+       struct v4l2_input *inp)
+{
+       dbg("%s\n",  __func__);
+
+       if (inp->index != 0)
+               return -EINVAL;
+
+       memset(inp, 0, sizeof(*inp));
+       inp->index = 0;
+
+       strncpy(inp->name, "Timb input 1", sizeof(inp->name) - 1);
+       inp->type = V4L2_INPUT_TYPE_CAMERA;
+       inp->std = V4L2_STD_ALL;
+
+       return 0;
+}
+
+static int timblogiw_g_input(struct file *file, void  *priv,
+       unsigned int *input)
+{
+       dbg("%s\n",  __func__);
+
+       *input = 0;
+
+       return 0;
+}
+
+static int timblogiw_s_input(struct file *file, void  *priv, unsigned int input)
+{
+       dbg("%s\n",  __func__);
+
+       if (input != 0)
+               return -EINVAL;
+       return 0;
+}
+
+static int timblogiw_streamon(struct file *file, void  *priv, unsigned int type)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+       struct timblogiw_frame *f;
+
+       dbg("%s\n",  __func__);
+
+       if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+               dbg("%s - No capture device\n", __func__);
+               return -EINVAL;
+       }
+
+       if (list_empty(&lw->inqueue)) {
+               dbg("%s - inqueue is empty\n", __func__);
+               return -EINVAL;
+       }
+
+       if (lw->stream == STREAM_ON)
+               return 0;
+
+       lw->stream = STREAM_ON;
+
+       f = list_entry(lw->inqueue.next,
+               struct timblogiw_frame, frame);
+
+       dbg("%s - f size: %d, bpr: %d, dma addr: %x\n", __func__,
+               timblogiw_frame_size(lw->cur_norm),
+               timblogiw_bytes_per_line(lw->cur_norm),
+               (unsigned int)lw->dma.transfer[lw->dma.curr].handle);
+
+       timb_start_dma(DMA_IRQ_VIDEO_RX,
+               lw->dma.transfer[lw->dma.curr].handle,
+               timblogiw_frame_size(lw->cur_norm),
+               timblogiw_bytes_per_line(lw->cur_norm));
+
+       return 0;
+}
+
+static int timblogiw_streamoff(struct file *file, void  *priv,
+       unsigned int type)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+               return -EINVAL;
+
+       if (lw->stream == STREAM_ON) {
+               unsigned long lock_flags;
+               spin_lock_irqsave(&lw->queue_lock, lock_flags);
+               timb_stop_dma(DMA_IRQ_VIDEO_RX);
+               lw->stream = STREAM_OFF;
+               spin_unlock_irqrestore(&lw->queue_lock, lock_flags);
+       }
+       timblogiw_empty_framequeues(lw);
+
+       return 0;
+}
+
+static int timblogiw_querystd(struct file *file, void  *priv, v4l2_std_id *std)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s\n",  __func__);
+
+       return v4l2_subdev_call(lw->sd_enc, video, querystd, std);
+}
+
+static int timblogiw_enum_framesizes(struct file *file, void  *priv,
+       struct v4l2_frmsizeenum *fsize)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+
+       dbg("%s - index: %d, format: %d\n",  __func__,
+               fsize->index, fsize->pixel_format);
+
+       if ((fsize->index != 0) ||
+               (fsize->pixel_format != V4L2_PIX_FMT_YUYV))
+               return -EINVAL;
+
+       fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+       fsize->discrete.width = lw->cur_norm->width;
+       fsize->discrete.height = lw->cur_norm->height;
+
+       return 0;
+}
+
+/*******************************
+ * Device Operations functions *
+ *******************************/
+
+static int timblogiw_open(struct file *file)
+{
+       struct video_device *vdev = video_devdata(file);
+       struct timblogiw *lw = video_get_drvdata(vdev);
+       v4l2_std_id std = V4L2_STD_UNKNOWN;
+
+       dbg("%s -\n", __func__);
+
+       mutex_init(&lw->fileop_lock);
+       spin_lock_init(&lw->queue_lock);
+       init_waitqueue_head(&lw->wait_frame);
+
+       mutex_lock(&lw->lock);
+
+       timblogiw_querystd(file, NULL, &std);
+       lw->video_dev->tvnorms = std;
+       lw->cur_norm = timblogiw_get_norm(std);
+
+       file->private_data = lw;
+       lw->stream = STREAM_OFF;
+       lw->num_frames = TIMBLOGIW_NUM_FRAMES;
+
+       timblogiw_empty_framequeues(lw);
+       timb_set_dma_interruptcb(DMA_IRQ_VIDEO_RX | DMA_IRQ_VIDEO_DROP,
+               timblogiw_isr, (void *)lw);
+       mutex_unlock(&lw->lock);
+
+       return 0;
+}
+
+static int timblogiw_close(struct file *file)
+{
+       struct timblogiw *lw = file->private_data;
+
+       dbg("%s - entry\n", __func__);
+
+       mutex_lock(&lw->lock);
+
+       timb_stop_dma(DMA_IRQ_VIDEO_RX);
+       timb_set_dma_interruptcb(DMA_IRQ_VIDEO_RX | DMA_IRQ_VIDEO_DROP, NULL,
+               NULL);
+       timblogiw_release_buffers(lw);
+
+       mutex_unlock(&lw->lock);
+       return 0;
+}
+
+static ssize_t timblogiw_read(struct file *file, char __user *data,
+       size_t count, loff_t *ppos)
+{
+       dbg("%s - read request\n", __func__);
+       return -EINVAL;
+}
+
+static void timblogiw_vm_open(struct vm_area_struct *vma)
+{
+       struct timblogiw_frame *f = vma->vm_private_data;
+       f->vma_use_count++;
+}
+
+static void timblogiw_vm_close(struct vm_area_struct *vma)
+{
+       struct timblogiw_frame *f = vma->vm_private_data;
+       f->vma_use_count--;
+}
+
+static struct vm_operations_struct timblogiw_vm_ops = {
+       .open = timblogiw_vm_open,
+       .close = timblogiw_vm_close,
+};
+
+static int timblogiw_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+       unsigned long size = vma->vm_end - vma->vm_start, start = vma->vm_start;
+       void *pos;
+       u32 i;
+       int ret = -EINVAL;
+
+       struct timblogiw *lw = filp->private_data;
+       dbg("%s\n", __func__);
+
+       if (mutex_lock_interruptible(&lw->fileop_lock))
+               return -ERESTARTSYS;
+
+       if (!(vma->vm_flags & VM_WRITE) ||
+               size != PAGE_ALIGN(lw->frame[0].buf.length))
+               goto error_unlock;
+
+       for (i = 0; i < lw->num_frames; i++)
+               if ((lw->frame[i].buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
+                       break;
+
+       if (i == lw->num_frames) {
+               dbg("%s - user supplied mapping address is out of range\n",
+                       __func__);
+               goto error_unlock;
+       }
+
+       vma->vm_flags |= VM_IO;
+       vma->vm_flags |= VM_RESERVED;   /* Do not swap out this VMA */
+
+       pos = lw->frame[i].bufmem;
+       while (size > 0) {              /* size is page-aligned */
+               if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
+                       dbg("%s - vm_insert_page failed\n", __func__);
+                       ret = -EAGAIN;
+                       goto error_unlock;
+               }
+               start += PAGE_SIZE;
+               pos += PAGE_SIZE;
+               size -= PAGE_SIZE;
+       }
+
+       vma->vm_ops = &timblogiw_vm_ops;
+       vma->vm_private_data = &lw->frame[i];
+       timblogiw_vm_open(vma);
+       ret = 0;
+
+error_unlock:
+       mutex_unlock(&lw->fileop_lock);
+       return ret;
+}
+
+
+void timblogiw_vdev_release(struct video_device *vdev)
+{
+       kfree(vdev);
+}
+
+static const struct v4l2_ioctl_ops timblogiw_ioctl_ops = {
+       .vidioc_querycap      = timblogiw_querycap,
+       .vidioc_enum_fmt_vid_cap  = timblogiw_enum_fmt,
+       .vidioc_g_fmt_vid_cap     = timblogiw_g_fmt,
+       .vidioc_try_fmt_vid_cap   = timblogiw_try_fmt,
+       .vidioc_s_fmt_vid_cap     = timblogiw_try_fmt,
+       .vidioc_reqbufs       = timblogiw_reqbufs,
+       .vidioc_querybuf      = timblogiw_querybuf,
+       .vidioc_qbuf          = timblogiw_qbuf,
+       .vidioc_dqbuf         = timblogiw_dqbuf,
+       .vidioc_g_std         = timblogiw_g_std,
+       .vidioc_s_std         = timblogiw_s_std,
+       .vidioc_enum_input    = timblogiw_enuminput,
+       .vidioc_g_input       = timblogiw_g_input,
+       .vidioc_s_input       = timblogiw_s_input,
+       .vidioc_streamon      = timblogiw_streamon,
+       .vidioc_streamoff     = timblogiw_streamoff,
+       .vidioc_querystd      = timblogiw_querystd,
+       .vidioc_enum_framesizes = timblogiw_enum_framesizes,
+};
+
+static const struct v4l2_file_operations timblogiw_fops = {
+       .owner          = THIS_MODULE,
+       .open           = timblogiw_open,
+       .release        = timblogiw_close,
+       .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
+       .mmap           = timblogiw_mmap,
+       .read           = timblogiw_read,
+};
+
+static const struct video_device timblogiw_template = {
+       .name           = TIMBLOGIWIN_NAME,
+       .fops           = &timblogiw_fops,
+       .ioctl_ops      = &timblogiw_ioctl_ops,
+       .release        = &timblogiw_vdev_release,
+       .minor          = -1
+};
+
+
+struct find_addr_arg {
+       char const *name;
+       struct i2c_client *client;
+};
+
+static int find_name(struct device *dev, void *argp)
+{
+       struct find_addr_arg    *arg = (struct find_addr_arg *)argp;
+       struct i2c_client       *client = i2c_verify_client(dev);
+
+       if (client && !strcmp(arg->name, client->name) && client->driver)
+               arg->client = client;
+
+       return 0;
+}
+
+static int timblogiw_probe(struct platform_device *dev)
+{
+       int err;
+       struct timblogiw *lw;
+       struct resource *iomem;
+       struct timb_video_platform_data *pdata = dev->dev.platform_data;
+       struct i2c_adapter *adapt;
+       struct i2c_client *encoder;
+       struct find_addr_arg find_arg;
+
+       if (!pdata) {
+               printk(KERN_ERR "timblogiw: Platform data missing\n");
+               err = -EINVAL;
+               goto err_mem;
+       }

drivers/media/video/timblogiw.c    (revision 867) renamed from drivers/media/video/timblogiw.c    (revision 0) +48 -0

+               goto err_mem;
+       }
+
+       /* find the PCI device from the parent... */
+       if (!dev->dev.parent) {
+               printk(KERN_ERR "timblogiw: No parent device found??\n");
+               err = -ENODEV;
+               goto err_encoder;
+       }
+
+       lw->dev = container_of(dev->dev.parent, struct pci_dev, dev);
+
+       /* find the video decoder */
+       adapt = i2c_get_adapter(pdata->i2c_adapter);
+       if (!adapt) {
+               printk(KERN_ERR "timblogiw: No I2C bus\n");
+               err = -ENODEV;
+               goto err_encoder;
+       }
+
+       /* now find the encoder */
+#ifdef MODULE
+       request_module(pdata->encoder);
+#endif
+       /* Code for finding the I2C child */
+       find_arg.name = pdata->encoder;
+       find_arg.client = NULL;
+       device_for_each_child(&adapt->dev, &find_arg, find_name);
+       encoder = find_arg.client;
+       i2c_put_adapter(adapt);
+
+       if (!encoder) {
+               printk(KERN_ERR "timblogiw: Failed to get encoder\n");
+               err = -ENODEV;
+               goto err_encoder;
+       }
+
+       /* Lock the module */
+       if (!try_module_get(encoder->driver->driver.owner)) {
+               err = -ENODEV;
+               goto err_encoder;
+       }
+
+       lw->sd_enc = i2c_get_clientdata(encoder);
+
+       mutex_init(&lw->lock);
+
+       lw->video_dev = video_device_alloc();