*
* Contact:
* Jinhyung Jo <jinhyung.jo@samsung.com>
- * DongKyun Yun <dk77.yun@samsung.com>
- * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
*
* Contributors:
* - S-Core Co., Ltd
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
-static unsigned debug = 0;
+#define MARUCAM_DEBUG_LEVEL 0
+
+static unsigned debug;
#define marucam_err(fmt, arg...) \
printk(KERN_ERR "marucam[%s] : " fmt, __func__, ##arg)
#define marucam_dbg(level, fmt, arg...) \
do { \
if (debug >= (level)) \
- printk(KERN_DEBUG "marucam[%s] : " fmt, __func__, ##arg); \
+ printk(KERN_DEBUG "marucam[%s] : " fmt, \
+ __func__, ##arg); \
} while (0)
#define MARUCAM_MODULE_NAME "marucam"
#define MARUCAM_MINOR_VERSION 24
#define MARUCAM_RELEASE 1
#define MARUCAM_VERSION \
- KERNEL_VERSION(MARUCAM_MAJOR_VERSION, MARUCAM_MINOR_VERSION, MARUCAM_RELEASE)
+ KERNEL_VERSION(MARUCAM_MAJOR_VERSION, \
+ MARUCAM_MINOR_VERSION, MARUCAM_RELEASE)
MODULE_DESCRIPTION("MARU Virtual Camera Driver");
MODULE_AUTHOR("Jinhyung Jo <jinhyung.jo@samsung.com>");
#define DFL_WIDTH 640
#define DFL_HEIGHT 480
-/* ------------------------------------------------------------------
- Basic structures
- ------------------------------------------------------------------*/
+/*
+ * Basic structures
+ */
#define MARUCAM_INIT 0x00
#define MARUCAM_OPEN 0x04
#define MARUCAM_CLOSE 0x08
struct marucam_device {
struct v4l2_device v4l2_dev;
- spinlock_t slock;
+ spinlock_t slock;
struct video_device *vfd;
struct pci_dev *pdev;
enum v4l2_buf_type type;
unsigned int width;
unsigned int height;
- unsigned int pixelformat;
- struct videobuf_queue vb_vidq;
+ unsigned int pixelformat;
+ struct videobuf_queue vb_vidq;
struct list_head active;
};
#define MAGIC_MARUCAM_MEM 0x18221223
-#define MAGIC_CHECK(is,should) if (unlikely((is) != (should))) \
- { marucam_err("magic mismatch: %x (expected %x)\n",is,should); BUG(); }
+#define MAGIC_CHECK(is, should) \
+ do { \
+ if (unlikely((is) != (should))) { \
+ marucam_err("magic mismatch: %x (expected %x)\n", \
+ is, should); \
+ BUG(); \
+ } \
+ } while (0)
-struct videobuf_marucam_memory
-{
- u32 magic;
- u32 mapped;
+struct videobuf_marucam_memory {
+ u32 magic;
+ u32 mapped;
};
static void
mem = q->bufs[i]->priv;
if (mem) {
MAGIC_CHECK(mem->magic, MAGIC_MARUCAM_MEM);
-
mem->mapped = 0;
}
return;
}
-static const struct vm_operations_struct videobuf_vm_ops =
-{
- .open = videobuf_vm_open,
- .close = videobuf_vm_close,
+static const struct vm_operations_struct videobuf_vm_ops = {
+ .open = videobuf_vm_open,
+ .close = videobuf_vm_close,
};
static struct videobuf_buffer *__videobuf_alloc_vb(size_t size)
return vb;
}
-static int __videobuf_iolock (struct videobuf_queue* q,
- struct videobuf_buffer *vb,
- struct v4l2_framebuffer *fbuf)
+static int __videobuf_iolock(struct videobuf_queue *q,
+ struct videobuf_buffer *vb,
+ struct v4l2_framebuffer *fbuf)
{
struct videobuf_marucam_memory *mem = vb->priv;
return -ENOMEM;
buf->map = map;
- map->q = q;
+ map->q = q;
buf->baddr = vma->vm_start;
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
retval = remap_pfn_range(vma, vma->vm_start,
- (((struct marucam_device*)q->priv_data)->mem_base + vma->vm_pgoff) >> PAGE_SHIFT,
- pages, vma->vm_page_prot);
+ (((struct marucam_device *)q->priv_data)->mem_base
+ + vma->vm_pgoff) >> PAGE_SHIFT,
+ pages, vma->vm_page_prot);
if (retval < 0) {
marucam_err("remap failed with error %d. ", retval);
mem->mapped = 0;
goto error;
}
- vma->vm_ops = &videobuf_vm_ops;
- vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
- vma->vm_private_data = map;
+ vma->vm_ops = &videobuf_vm_ops;
+ vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
+ vma->vm_private_data = map;
videobuf_vm_open(vma);
}
static struct videobuf_qtype_ops qops = {
- .magic = MAGIC_QTYPE_OPS,
-
- .alloc_vb = __videobuf_alloc_vb,
- .iolock = __videobuf_iolock,
- .mmap_mapper = __videobuf_mmap_mapper,
+ .magic = MAGIC_QTYPE_OPS,
+ .alloc_vb = __videobuf_alloc_vb,
+ .iolock = __videobuf_iolock,
+ .mmap_mapper = __videobuf_mmap_mapper,
};
-void videobuf_queue_marucam_init(struct videobuf_queue* q,
+void videobuf_queue_marucam_init(struct videobuf_queue *q,
struct videobuf_queue_ops *ops,
void *dev,
spinlock_t *irqlock,
}
-/* ------------------------------------------------------------------
- interrupt handling
- ------------------------------------------------------------------*/
+/*
+ * interrupt handling
+ */
static int get_image_size(struct marucam_device *dev)
{
int size;
switch (dev->pixelformat) {
- case V4L2_PIX_FMT_RGB24:
- case V4L2_PIX_FMT_BGR24:
- size = dev->width * dev->height * 3;
- break;
- case V4L2_PIX_FMT_YUV420:
- case V4L2_PIX_FMT_YVU420:
- case V4L2_PIX_FMT_NV12:
- size = (dev->width * dev->height * 3) /2;
- break;
- case V4L2_PIX_FMT_YUYV:
- default:
- size = dev->width * dev->height * 2;
- break;
+ case V4L2_PIX_FMT_RGB24:
+ case V4L2_PIX_FMT_BGR24:
+ size = dev->width * dev->height * 3;
+ break;
+ case V4L2_PIX_FMT_YUV420:
+ case V4L2_PIX_FMT_YVU420:
+ case V4L2_PIX_FMT_NV12:
+ size = (dev->width * dev->height * 3) / 2;
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ default:
+ size = dev->width * dev->height * 2;
+ break;
}
return size;
unsigned long flags = 0;
spin_lock_irqsave(q->irqlock, flags);
- if (list_empty(&dev->active)) {
+ if (list_empty(&dev->active))
goto done;
- }
buf = list_entry(dev->active.next, struct videobuf_buffer, queue);
- if (!waitqueue_active(&buf->done)) {
+ if (!waitqueue_active(&buf->done))
goto done;
- }
+
list_del(&buf->queue);
buf->state = VIDEOBUF_DONE;
return IRQ_HANDLED;
}
-/* ------------------------------------------------------------------
- IOCTL vidioc handling
- ------------------------------------------------------------------*/
+/*
+ * IOCTL vidioc handling
+ */
static int vidioc_querycap(struct file *file, void *priv,
struct v4l2_capability *cap)
{
strcpy(cap->card, MARUCAM_MODULE_NAME);
strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
cap->version = MARUCAM_VERSION;
- cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
- V4L2_CAP_STREAMING;
+ cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+
return 0;
}
iowrite32(0, dev->mmregs + MARUCAM_ENUM_FMT);
ret = ioread32(dev->mmregs + MARUCAM_ENUM_FMT);
- if (ret > 0)
+ if (ret > 0)
return -(ret);
- f->index = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->flags = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->index = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->flags = ioread32(dev->mmregs + MARUCAM_G_DATA);
f->pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
ioread32_rep(dev->mmregs + MARUCAM_G_DATA, f->description, 8);
iowrite32(0, dev->mmregs + MARUCAM_DTC);
iowrite32(0, dev->mmregs + MARUCAM_G_FMT);
ret = ioread32(dev->mmregs + MARUCAM_G_FMT);
- if (ret > 0)
+ if (ret > 0)
return -(ret);
-
- f->fmt.pix.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.field = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.bytesperline = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.sizeimage = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.colorspace = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.priv = ioread32(dev->mmregs + MARUCAM_G_DATA);
-
- dev->pixelformat = f->fmt.pix.pixelformat;
- dev->width = f->fmt.pix.width;
- dev->height = f->fmt.pix.height;
- dev->vb_vidq.field = f->fmt.pix.field;
- dev->type = f->type;
+
+ f->fmt.pix.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.field = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.bytesperline = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.sizeimage = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.colorspace = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.priv = ioread32(dev->mmregs + MARUCAM_G_DATA);
+
+ dev->pixelformat = f->fmt.pix.pixelformat;
+ dev->width = f->fmt.pix.width;
+ dev->height = f->fmt.pix.height;
+ dev->vb_vidq.field = f->fmt.pix.field;
+ dev->type = f->type;
return 0;
}
iowrite32(0, dev->mmregs + MARUCAM_TRY_FMT);
ret = ioread32(dev->mmregs + MARUCAM_TRY_FMT);
- if (ret > 0)
+ if (ret > 0)
return -(ret);
- f->fmt.pix.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.field = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.bytesperline = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.sizeimage = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.colorspace = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.priv = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.field = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.bytesperline = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.sizeimage = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.colorspace = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.priv = ioread32(dev->mmregs + MARUCAM_G_DATA);
return 0;
}
return -(ret);
}
- f->fmt.pix.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.field = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.bytesperline = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.sizeimage = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.colorspace = ioread32(dev->mmregs + MARUCAM_G_DATA);
- f->fmt.pix.priv = ioread32(dev->mmregs + MARUCAM_G_DATA);
-
- dev->pixelformat = f->fmt.pix.pixelformat;
- dev->width = f->fmt.pix.width;
- dev->height = f->fmt.pix.height;
- dev->vb_vidq.field = f->fmt.pix.field;
- dev->type = f->type;
-
+ f->fmt.pix.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.field = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.pixelformat = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.bytesperline = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.sizeimage = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.colorspace = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ f->fmt.pix.priv = ioread32(dev->mmregs + MARUCAM_G_DATA);
+
+ dev->pixelformat = f->fmt.pix.pixelformat;
+ dev->width = f->fmt.pix.width;
+ dev->height = f->fmt.pix.height;
+ dev->vb_vidq.field = f->fmt.pix.field;
+ dev->type = f->type;
+
return 0;
}
dev->type = p->type;
- return (videobuf_reqbufs(&dev->vb_vidq, p));
+ return videobuf_reqbufs(&dev->vb_vidq, p);
}
static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
struct marucam_device *dev = priv;
- return (videobuf_querybuf(&dev->vb_vidq, p));
+ return videobuf_querybuf(&dev->vb_vidq, p);
}
static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
struct marucam_device *dev = priv;
- return (videobuf_qbuf(&dev->vb_vidq, p));
+ return videobuf_qbuf(&dev->vb_vidq, p);
}
static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
struct marucam_device *dev = priv;
- return (videobuf_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK));
+ return videobuf_dqbuf(&dev->vb_vidq, p, file->f_flags & O_NONBLOCK);
}
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
}
ret = videobuf_streamon(&dev->vb_vidq);
- if (ret < 0) {
+ if (ret < 0)
marucam_err("videobuf_streamon failed!, ret = %d\n", ret);
- }
+
return ret;
}
}
ret = videobuf_streamoff(&dev->vb_vidq);
- if (ret < 0) {
+ if (ret < 0)
marucam_err("videobuf_streamoff failed!\n");
- }
return ret;
}
inp->type = V4L2_INPUT_TYPE_CAMERA;
sprintf(inp->name, "MARU Virtual Camera %u", inp->index);
- return (0);
+ return 0;
}
static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
{
*i = 0;
- return (0);
+ return 0;
}
static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
{
- return (0);
+ return 0;
}
-/* --- controls ---------------------------------------------- */
+/* controls
+ *
+ */
static int vidioc_queryctrl(struct file *file, void *priv,
struct v4l2_queryctrl *qc)
{
iowrite32(0, dev->mmregs + MARUCAM_DTC);
iowrite32(qc->id, dev->mmregs + MARUCAM_S_DATA);
-
+
iowrite32(0, dev->mmregs + MARUCAM_QCTRL);
ret = ioread32(dev->mmregs + MARUCAM_QCTRL);
-
+
if (ret > 0)
return -(ret);
- qc->id = ioread32(dev->mmregs + MARUCAM_G_DATA);
- qc->minimum = ioread32(dev->mmregs + MARUCAM_G_DATA);
- qc->maximum = ioread32(dev->mmregs + MARUCAM_G_DATA);
- qc->step = ioread32(dev->mmregs + MARUCAM_G_DATA);
- qc->default_value = ioread32(dev->mmregs + MARUCAM_G_DATA);
- qc->flags = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ qc->id = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ qc->minimum = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ qc->maximum = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ qc->step = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ qc->default_value = ioread32(dev->mmregs + MARUCAM_G_DATA);
+ qc->flags = ioread32(dev->mmregs + MARUCAM_G_DATA);
ioread32_rep(dev->mmregs + MARUCAM_G_DATA, qc->name, 8);
-
+
return 0;
}
iowrite32(0, dev->mmregs + MARUCAM_G_CTRL);
ret = ioread32(dev->mmregs + MARUCAM_G_CTRL);
-
+
if (ret > 0)
return -(ret);
-
+
ctrl->value = ioread32(dev->mmregs + MARUCAM_G_DATA);
return 0;
{
struct marucam_device *dev = priv;
uint32_t ret;
-
+
iowrite32(0, dev->mmregs + MARUCAM_DTC);
iowrite32(ctrl->id, dev->mmregs + MARUCAM_S_DATA);
iowrite32(ctrl->value, dev->mmregs + MARUCAM_S_DATA);
-
+
iowrite32(0, dev->mmregs + MARUCAM_S_CTRL);
ret = ioread32(dev->mmregs + MARUCAM_S_CTRL);
iowrite32(0, dev->mmregs + MARUCAM_S_PARAM);
ret = ioread32(dev->mmregs + MARUCAM_S_PARAM);
-
+
if (ret > 0)
return -(ret);
if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
-
+
iowrite32(0, dev->mmregs + MARUCAM_DTC);
iowrite32(0, dev->mmregs + MARUCAM_G_PARAM);
ret = ioread32(dev->mmregs + MARUCAM_G_PARAM);
- if (ret > 0)
+ if (ret > 0)
return -(ret);
-
+
cp->capability = ioread32(dev->mmregs + MARUCAM_G_DATA);
cp->timeperframe.numerator = ioread32(dev->mmregs + MARUCAM_G_DATA);
cp->timeperframe.denominator = ioread32(dev->mmregs + MARUCAM_G_DATA);
- return 0;
+ return 0;
}
static int vidioc_enum_framesizes(struct file *file, void *priv,
fsize->discrete.width = ioread32(dev->mmregs + MARUCAM_G_DATA);
fsize->discrete.height = ioread32(dev->mmregs + MARUCAM_G_DATA);
- return 0;
+ return 0;
}
static int vidioc_enum_frameintervals(struct file *file, void *priv,
marucam_dbg(1, "field=%d\n", field);
vb->size = get_image_size(dev);
-
+
if (0 != vb->baddr && vb->bsize < vb->size)
return -EINVAL;
goto fail;
}
- vb->width = dev->width;
- vb->height = dev->height;
- vb->field = field;
- vb->state = VIDEOBUF_PREPARED;
+ vb->width = dev->width;
+ vb->height = dev->height;
+ vb->field = field;
+ vb->state = VIDEOBUF_PREPARED;
return 0;
struct marucam_device *dev = video_drvdata(file);
int ret;
- file->private_data = dev;
- dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- dev->pixelformat = V4L2_PIX_FMT_YUYV;
- dev->width = DFL_WIDTH;
- dev->height = DFL_HEIGHT;
+ file->private_data = dev;
+ dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ dev->pixelformat = V4L2_PIX_FMT_YUYV;
+ dev->width = DFL_WIDTH;
+ dev->height = DFL_HEIGHT;
ret = request_irq(dev->pdev->irq, marucam_irq_handler,
IRQF_SHARED, MARUCAM_MODULE_NAME, dev);
if (ret) {
- marucam_err("request_irq failed!!! irq num : %d\n", dev->pdev->irq);
+ marucam_err("request_irq failed!!! irq#(%d)\n", dev->pdev->irq);
return ret;
}
videobuf_queue_marucam_init(&dev->vb_vidq, &marucam_video_qops,
- &dev->pdev->dev, &dev->slock, dev->type, V4L2_FIELD_NONE,
- sizeof(struct videobuf_buffer), dev, NULL);
-
+ &dev->pdev->dev, &dev->slock, dev->type,
+ V4L2_FIELD_NONE, sizeof(struct videobuf_buffer),
+ dev, NULL);
+
iowrite32(0, dev->mmregs + MARUCAM_OPEN);
ret = (int)ioread32(dev->mmregs + MARUCAM_OPEN);
videobuf_mmap_free(&dev->vb_vidq);
free_irq(dev->pdev->irq, dev);
-
+
iowrite32(0, dev->mmregs + MARUCAM_CLOSE);
ret = ioread32(dev->mmregs + MARUCAM_CLOSE);
if (ret > 0) {
mutex_lock(&q->vb_lock);
if (q->streaming) {
if (!list_empty(&q->stream))
- buf = list_entry(q->stream.next, struct videobuf_buffer, stream);
+ buf = list_entry(q->stream.next,
+ struct videobuf_buffer, stream);
}
if (!buf)
ret = POLLERR;
if (ret == 0) {
poll_wait(file, &buf->done, wait);
- if (buf->state == VIDEOBUF_DONE || buf->state == VIDEOBUF_ERROR) {
+ if (buf->state == VIDEOBUF_DONE || buf->state == VIDEOBUF_ERROR)
ret = POLLIN | POLLRDNORM;
- } else {
+ else
iowrite32(buf->i, dev->mmregs + MARUCAM_REQFRAME);
- }
}
mutex_unlock(&q->vb_lock);
return ret;
}
static const struct v4l2_ioctl_ops marucam_ioctl_ops = {
- .vidioc_querycap = vidioc_querycap,
+ .vidioc_querycap = vidioc_querycap,
.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
- .vidioc_reqbufs = vidioc_reqbufs,
- .vidioc_querybuf = vidioc_querybuf,
- .vidioc_qbuf = vidioc_qbuf,
- .vidioc_dqbuf = vidioc_dqbuf,
- .vidioc_s_std = vidioc_s_std,
- .vidioc_enum_input = vidioc_enum_input,
- .vidioc_g_input = vidioc_g_input,
- .vidioc_s_input = vidioc_s_input,
- .vidioc_queryctrl = vidioc_queryctrl,
- .vidioc_g_ctrl = vidioc_g_ctrl,
- .vidioc_s_ctrl = vidioc_s_ctrl,
- .vidioc_streamon = vidioc_streamon,
- .vidioc_streamoff = vidioc_streamoff,
- .vidioc_g_parm = vidioc_g_parm,
- .vidioc_s_parm = vidioc_s_parm,
+ .vidioc_reqbufs = vidioc_reqbufs,
+ .vidioc_querybuf = vidioc_querybuf,
+ .vidioc_qbuf = vidioc_qbuf,
+ .vidioc_dqbuf = vidioc_dqbuf,
+ .vidioc_s_std = vidioc_s_std,
+ .vidioc_enum_input = vidioc_enum_input,
+ .vidioc_g_input = vidioc_g_input,
+ .vidioc_s_input = vidioc_s_input,
+ .vidioc_queryctrl = vidioc_queryctrl,
+ .vidioc_g_ctrl = vidioc_g_ctrl,
+ .vidioc_s_ctrl = vidioc_s_ctrl,
+ .vidioc_streamon = vidioc_streamon,
+ .vidioc_streamoff = vidioc_streamoff,
+ .vidioc_g_parm = vidioc_g_parm,
+ .vidioc_s_parm = vidioc_s_parm,
.vidioc_enum_framesizes = vidioc_enum_framesizes,
.vidioc_enum_frameintervals = vidioc_enum_frameintervals,
};
Initialization and module stuff
------------------------------------------------------------------*/
-static struct pci_device_id marucam_pci_id_tbl[] = {
- {
- .vendor = PCI_VENDOR_ID_TIZEN,
- .device = PCI_DEVICE_ID_VIRTUAL_CAMERA,
- .subvendor = PCI_ANY_ID,
- .subdevice = PCI_ANY_ID,
- }
-};
+DEFINE_PCI_DEVICE_TABLE(marucam_pci_id_tbl) = {
+ { PCI_DEVICE(PCI_VENDOR_ID_TIZEN, PCI_DEVICE_ID_VIRTUAL_CAMERA) } };
-MODULE_DEVICE_TABLE(pci, marucam_pci_id_tbl);
-
-static int marucam_pci_initdev(struct pci_dev *pdev, const struct pci_device_id *id)
+static int marucam_pci_initdev(struct pci_dev *pdev,
+ const struct pci_device_id *id)
{
int ret;
struct marucam_device *dev;
+ debug = MARUCAM_DEBUG_LEVEL;
+
dev = kzalloc(sizeof(struct marucam_device), GFP_KERNEL);
if (!dev)
return -ENOMEM;
spin_lock_init(&dev->slock);
dev->pdev = pdev;
-
+
ret = -ENOMEM;
dev->vfd = video_device_alloc();
if (!dev->vfd) {
marucam_err("video_device_alloc() failed!!\n");
goto out_unreg;
}
-
+
memcpy(dev->vfd, &marucam_video_dev, sizeof(marucam_video_dev));
dev->vfd->parent = &dev->pdev->dev;
dev->vfd->v4l2_dev = &dev->v4l2_dev;
-
+
ret = pci_enable_device(dev->pdev);
if (ret)
goto rel_vdev;
ret = -EIO;
dev->mem_base = pci_resource_start(dev->pdev, 0);
dev->mem_size = pci_resource_len(dev->pdev, 0);
-
+
if (!dev->mem_base) {
marucam_err("pci_resource_start failed!!\n");
goto out_disable;
}
- if (!request_mem_region(dev->mem_base, dev->mem_size, MARUCAM_MODULE_NAME)) {
+ if (!request_mem_region(dev->mem_base, dev->mem_size,
+ MARUCAM_MODULE_NAME)) {
marucam_err("request_mem_region(mem) failed!!\n");
goto out_disable;
- }
+ }
dev->io_base = pci_resource_start(dev->pdev, 1);
dev->io_size = pci_resource_len(dev->pdev, 1);
-
+
if (!dev->io_base) {
marucam_err("pci_resource_start failed!!\n");
goto out_rel_mem_region;
}
- if (!request_mem_region(dev->io_base, dev->io_size, MARUCAM_MODULE_NAME)) {
+ if (!request_mem_region(dev->io_base, dev->io_size,
+ MARUCAM_MODULE_NAME)) {
marucam_err("request_mem_region(io) failed!!\n");
goto out_disable;
}
-
+
dev->mmregs = ioremap(dev->io_base, dev->io_size);
if (!dev->mmregs) {
marucam_err("ioremap failed!!\n");
video_set_drvdata(dev->vfd, dev);
pci_set_drvdata(pdev, dev);
- snprintf(dev->vfd->name, sizeof(dev->vfd->name), "%s (%i)",
+ snprintf(dev->vfd->name, sizeof(dev->vfd->name), "%s (%i)",
marucam_video_dev.name, dev->vfd->num);
- v4l2_info(&dev->v4l2_dev, "V4L2 device registerd as /dev/video%d\n",
- dev->vfd->num);
+ marucam_info("V4L2 device registerd as /dev/video%d\n", dev->vfd->num);
return 0;
v4l2_device_unregister(&dev->v4l2_dev);
out_free:
kfree(dev);
-
+
return ret;
}
}
video_unregister_device(dev->vfd);
-
+
if (dev->mmregs) {
iounmap(dev->mmregs);
dev->mmregs = 0;
}
-
+
if (dev->io_base) {
release_mem_region(dev->io_base, dev->io_size);
dev->io_base = 0;
static int __init marucam_init(void)
{
int ret = 0;
-
+
ret = pci_register_driver(&marucam_pci_driver);
if (ret < 0) {
marucam_info("Error %d while loading marucam driver\n", ret);
return ret;
}
- marucam_info("MARU Virtual Camera Driver ver %u.%u.%u successfully loaded.\n",
- (MARUCAM_VERSION >> 16) & 0xFF, (MARUCAM_VERSION >> 8) & 0xFF,
- MARUCAM_VERSION & 0xFF);
+ marucam_info("MARU Camera Driver ver %u.%u.%u successfully loaded.\n",
+ (MARUCAM_VERSION >> 16) & 0xFF, (MARUCAM_VERSION >> 8) & 0xFF,
+ MARUCAM_VERSION & 0xFF);
return ret;
}
projects / sdk / emulator / emulator-kernel.git / commitdiff