2 * Copyright 2008-2010 Freescale Semiconductor, Inc. All Rights Reserved.
4 * Freescale VIU video driver
6 * Authors: Hongjun Chen <hong-jun.chen@freescale.com>
7 * Porting to 2.6.35 by DENX Software Engineering,
8 * Anatolij Gustschin <agust@denx.de>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
17 #include <linux/module.h>
18 #include <linux/clk.h>
19 #include <linux/kernel.h>
20 #include <linux/i2c.h>
21 #include <linux/init.h>
22 #include <linux/interrupt.h>
24 #include <linux/of_platform.h>
25 #include <linux/slab.h>
26 #include <linux/version.h>
27 #include <media/v4l2-common.h>
28 #include <media/v4l2-device.h>
29 #include <media/v4l2-ioctl.h>
30 #include <media/videobuf-dma-contig.h>
32 #define DRV_NAME "fsl_viu"
33 #define VIU_MAJOR_VERSION 0
34 #define VIU_MINOR_VERSION 5
36 #define VIU_VERSION KERNEL_VERSION(VIU_MAJOR_VERSION, \
40 #define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
42 #define VIU_VID_MEM_LIMIT 4 /* Video memory limit, in Mb */
44 /* I2C address of video decoder chip is 0x4A */
45 #define VIU_VIDEO_DECODER_ADDR 0x25
47 /* supported controls */
48 static struct v4l2_queryctrl viu_qctrl
[] = {
50 .id
= V4L2_CID_BRIGHTNESS
,
51 .type
= V4L2_CTRL_TYPE_INTEGER
,
59 .id
= V4L2_CID_CONTRAST
,
60 .type
= V4L2_CTRL_TYPE_INTEGER
,
65 .default_value
= 0x10,
68 .id
= V4L2_CID_SATURATION
,
69 .type
= V4L2_CTRL_TYPE_INTEGER
,
78 .type
= V4L2_CTRL_TYPE_INTEGER
,
88 static int qctl_regs
[ARRAY_SIZE(viu_qctrl
)];
90 static int info_level
;
92 #define dprintk(level, fmt, arg...) \
94 if (level <= info_level) \
95 printk(KERN_DEBUG "viu: " fmt , ## arg); \
103 u32 fourcc
; /* v4l2 format id */
108 static struct viu_fmt formats
[] = {
110 .name
= "RGB-16 (5/B-6/G-5/R)",
111 .fourcc
= V4L2_PIX_FMT_RGB565
,
112 .pixelformat
= V4L2_PIX_FMT_RGB565
,
115 .name
= "RGB-32 (A-R-G-B)",
116 .fourcc
= V4L2_PIX_FMT_RGB32
,
117 .pixelformat
= V4L2_PIX_FMT_RGB32
,
125 /* buffer for one video frame */
127 /* common v4l buffer stuff -- must be first */
128 struct videobuf_buffer vb
;
132 struct viu_dmaqueue
{
134 struct list_head active
;
135 struct list_head queued
;
136 struct timer_list timeout
;
159 } __attribute__ ((packed
));
162 struct v4l2_device v4l2_dev
;
168 /* various device info */
169 struct video_device
*vdev
;
170 struct viu_dmaqueue vidq
;
171 enum v4l2_field capfield
;
176 /* Hardware register area */
179 /* Interrupt vector */
181 struct viu_status irqs
;
184 struct v4l2_framebuffer ovbuf
;
185 struct viu_fmt
*ovfmt
;
186 unsigned int ovenable
;
187 enum v4l2_field ovfield
;
190 struct v4l2_rect crop_current
;
196 struct v4l2_subdev
*decoder
;
205 struct videobuf_queue vb_vidq
;
206 spinlock_t vbq_lock
; /* spinlock for the videobuf queue */
209 struct v4l2_window win
;
210 struct v4l2_clip clips
[1];
214 int width
, height
, sizeimage
;
215 enum v4l2_buf_type type
;
218 static struct viu_reg reg_val
;
221 * Macro definitions of VIU registers
224 /* STATUS_CONFIG register */
228 ERR_MASK
= 0x0f << 4, /* Error code mask */
229 ERR_NO
= 0x00, /* No error */
230 ERR_DMA_V
= 0x01 << 4, /* DMA in vertical active */
231 ERR_DMA_VB
= 0x02 << 4, /* DMA in vertical blanking */
232 ERR_LINE_TOO_LONG
= 0x04 << 4, /* Line too long */
233 ERR_TOO_MANG_LINES
= 0x05 << 4, /* Too many lines in field */
234 ERR_LINE_TOO_SHORT
= 0x06 << 4, /* Line too short */
235 ERR_NOT_ENOUGH_LINE
= 0x07 << 4, /* Not enough lines in field */
236 ERR_FIFO_OVERFLOW
= 0x08 << 4, /* FIFO overflow */
237 ERR_FIFO_UNDERFLOW
= 0x09 << 4, /* FIFO underflow */
238 ERR_1bit_ECC
= 0x0a << 4, /* One bit ECC error */
239 ERR_MORE_ECC
= 0x0b << 4, /* Two/more bits ECC error */
241 INT_FIELD_EN
= 0x01 << 8, /* Enable field interrupt */
242 INT_VSYNC_EN
= 0x01 << 9, /* Enable vsync interrupt */
243 INT_HSYNC_EN
= 0x01 << 10, /* Enable hsync interrupt */
244 INT_VSTART_EN
= 0x01 << 11, /* Enable vstart interrupt */
245 INT_DMA_END_EN
= 0x01 << 12, /* Enable DMA end interrupt */
246 INT_ERROR_EN
= 0x01 << 13, /* Enable error interrupt */
247 INT_ECC_EN
= 0x01 << 14, /* Enable ECC interrupt */
249 INT_FIELD_STATUS
= 0x01 << 16, /* field interrupt status */
250 INT_VSYNC_STATUS
= 0x01 << 17, /* vsync interrupt status */
251 INT_HSYNC_STATUS
= 0x01 << 18, /* hsync interrupt status */
252 INT_VSTART_STATUS
= 0x01 << 19, /* vstart interrupt status */
253 INT_DMA_END_STATUS
= 0x01 << 20, /* DMA end interrupt status */
254 INT_ERROR_STATUS
= 0x01 << 21, /* error interrupt status */
256 DMA_ACT
= 0x01 << 27, /* Enable DMA transfer */
257 FIELD_NO
= 0x01 << 28, /* Field number */
258 DITHER_ON
= 0x01 << 29, /* Dithering is on */
259 ROUND_ON
= 0x01 << 30, /* Round is on */
260 MODE_32BIT
= 0x01 << 31, /* Data in RGBa888,
265 #define norm_maxw() 720
266 #define norm_maxh() 576
268 #define INT_ALL_STATUS (INT_FIELD_STATUS | INT_VSYNC_STATUS | \
269 INT_HSYNC_STATUS | INT_VSTART_STATUS | \
270 INT_DMA_END_STATUS | INT_ERROR_STATUS)
272 #define NUM_FORMATS ARRAY_SIZE(formats)
274 static irqreturn_t
viu_intr(int irq
, void *dev_id
);
276 struct viu_fmt
*format_by_fourcc(int fourcc
)
280 for (i
= 0; i
< NUM_FORMATS
; i
++) {
281 if (formats
[i
].pixelformat
== fourcc
)
285 dprintk(0, "unknown pixelformat:'%4.4s'\n", (char *)&fourcc
);
289 void viu_start_dma(struct viu_dev
*dev
)
291 struct viu_reg
*vr
= dev
->vr
;
295 /* Enable DMA operation */
296 out_be32(&vr
->status_cfg
, SOFT_RST
);
297 out_be32(&vr
->status_cfg
, INT_FIELD_EN
);
300 void viu_stop_dma(struct viu_dev
*dev
)
302 struct viu_reg
*vr
= dev
->vr
;
306 out_be32(&vr
->status_cfg
, 0);
308 /* Clear pending interrupts */
309 status_cfg
= in_be32(&vr
->status_cfg
);
310 if (status_cfg
& 0x3f0000)
311 out_be32(&vr
->status_cfg
, status_cfg
& 0x3f0000);
313 if (status_cfg
& DMA_ACT
) {
315 status_cfg
= in_be32(&vr
->status_cfg
);
316 if (status_cfg
& INT_DMA_END_STATUS
)
321 /* timed out, issue soft reset */
322 out_be32(&vr
->status_cfg
, SOFT_RST
);
323 out_be32(&vr
->status_cfg
, 0);
325 /* clear DMA_END and other pending irqs */
326 out_be32(&vr
->status_cfg
, status_cfg
& 0x3f0000);
333 static int restart_video_queue(struct viu_dmaqueue
*vidq
)
335 struct viu_buf
*buf
, *prev
;
337 dprintk(1, "%s vidq=0x%08lx\n", __func__
, (unsigned long)vidq
);
338 if (!list_empty(&vidq
->active
)) {
339 buf
= list_entry(vidq
->active
.next
, struct viu_buf
, vb
.queue
);
340 dprintk(2, "restart_queue [%p/%d]: restart dma\n",
343 viu_stop_dma(vidq
->dev
);
345 /* cancel all outstanding capture requests */
346 list_for_each_entry_safe(buf
, prev
, &vidq
->active
, vb
.queue
) {
347 list_del(&buf
->vb
.queue
);
348 buf
->vb
.state
= VIDEOBUF_ERROR
;
349 wake_up(&buf
->vb
.done
);
351 mod_timer(&vidq
->timeout
, jiffies
+BUFFER_TIMEOUT
);
357 if (list_empty(&vidq
->queued
))
359 buf
= list_entry(vidq
->queued
.next
, struct viu_buf
, vb
.queue
);
361 list_del(&buf
->vb
.queue
);
362 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
364 dprintk(1, "Restarting video dma\n");
365 viu_stop_dma(vidq
->dev
);
366 viu_start_dma(vidq
->dev
);
368 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
369 mod_timer(&vidq
->timeout
, jiffies
+BUFFER_TIMEOUT
);
370 dprintk(2, "[%p/%d] restart_queue - first active\n",
373 } else if (prev
->vb
.width
== buf
->vb
.width
&&
374 prev
->vb
.height
== buf
->vb
.height
&&
375 prev
->fmt
== buf
->fmt
) {
376 list_del(&buf
->vb
.queue
);
377 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
378 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
379 dprintk(2, "[%p/%d] restart_queue - move to active\n",
388 static void viu_vid_timeout(unsigned long data
)
390 struct viu_dev
*dev
= (struct viu_dev
*)data
;
392 struct viu_dmaqueue
*vidq
= &dev
->vidq
;
394 while (!list_empty(&vidq
->active
)) {
395 buf
= list_entry(vidq
->active
.next
, struct viu_buf
, vb
.queue
);
396 list_del(&buf
->vb
.queue
);
397 buf
->vb
.state
= VIDEOBUF_ERROR
;
398 wake_up(&buf
->vb
.done
);
399 dprintk(1, "viu/0: [%p/%d] timeout\n", buf
, buf
->vb
.i
);
402 restart_video_queue(vidq
);
406 * Videobuf operations
408 static int buffer_setup(struct videobuf_queue
*vq
, unsigned int *count
,
411 struct viu_fh
*fh
= vq
->priv_data
;
413 *size
= fh
->width
* fh
->height
* fh
->fmt
->depth
>> 3;
417 while (*size
* *count
> VIU_VID_MEM_LIMIT
* 1024 * 1024)
420 dprintk(1, "%s, count=%d, size=%d\n", __func__
, *count
, *size
);
424 static void free_buffer(struct videobuf_queue
*vq
, struct viu_buf
*buf
)
426 struct videobuf_buffer
*vb
= &buf
->vb
;
429 BUG_ON(in_interrupt());
431 videobuf_waiton(vq
, &buf
->vb
, 0, 0);
433 if (vq
->int_ops
&& vq
->int_ops
->vaddr
)
434 vaddr
= vq
->int_ops
->vaddr(vb
);
437 videobuf_dma_contig_free(vq
, &buf
->vb
);
439 buf
->vb
.state
= VIDEOBUF_NEEDS_INIT
;
442 inline int buffer_activate(struct viu_dev
*dev
, struct viu_buf
*buf
)
444 struct viu_reg
*vr
= dev
->vr
;
447 /* setup the DMA base address */
448 reg_val
.field_base_addr
= videobuf_to_dma_contig(&buf
->vb
);
450 dprintk(1, "buffer_activate [%p/%d]: dma addr 0x%lx\n",
451 buf
, buf
->vb
.i
, (unsigned long)reg_val
.field_base_addr
);
453 /* interlace is on by default, set horizontal DMA increment */
454 reg_val
.status_cfg
= 0;
455 bpp
= buf
->fmt
->depth
>> 3;
458 reg_val
.status_cfg
&= ~MODE_32BIT
;
459 reg_val
.dma_inc
= buf
->vb
.width
* 2;
462 reg_val
.status_cfg
|= MODE_32BIT
;
463 reg_val
.dma_inc
= buf
->vb
.width
* 4;
466 dprintk(0, "doesn't support color depth(%d)\n",
471 /* setup picture_count register */
472 reg_val
.picture_count
= (buf
->vb
.height
/ 2) << 16 |
475 reg_val
.status_cfg
|= DMA_ACT
| INT_DMA_END_EN
| INT_FIELD_EN
;
477 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
478 dev
->capfield
= buf
->vb
.field
;
480 /* reset dma increment if needed */
481 if (!V4L2_FIELD_HAS_BOTH(buf
->vb
.field
))
484 out_be32(&vr
->dma_inc
, reg_val
.dma_inc
);
485 out_be32(&vr
->picture_count
, reg_val
.picture_count
);
486 out_be32(&vr
->field_base_addr
, reg_val
.field_base_addr
);
487 mod_timer(&dev
->vidq
.timeout
, jiffies
+ BUFFER_TIMEOUT
);
491 static int buffer_prepare(struct videobuf_queue
*vq
,
492 struct videobuf_buffer
*vb
,
493 enum v4l2_field field
)
495 struct viu_fh
*fh
= vq
->priv_data
;
496 struct viu_buf
*buf
= container_of(vb
, struct viu_buf
, vb
);
499 BUG_ON(fh
->fmt
== NULL
);
501 if (fh
->width
< 48 || fh
->width
> norm_maxw() ||
502 fh
->height
< 32 || fh
->height
> norm_maxh())
504 buf
->vb
.size
= (fh
->width
* fh
->height
* fh
->fmt
->depth
) >> 3;
505 if (buf
->vb
.baddr
!= 0 && buf
->vb
.bsize
< buf
->vb
.size
)
508 if (buf
->fmt
!= fh
->fmt
||
509 buf
->vb
.width
!= fh
->width
||
510 buf
->vb
.height
!= fh
->height
||
511 buf
->vb
.field
!= field
) {
513 buf
->vb
.width
= fh
->width
;
514 buf
->vb
.height
= fh
->height
;
515 buf
->vb
.field
= field
;
518 if (buf
->vb
.state
== VIDEOBUF_NEEDS_INIT
) {
519 rc
= videobuf_iolock(vq
, &buf
->vb
, NULL
);
523 buf
->vb
.width
= fh
->width
;
524 buf
->vb
.height
= fh
->height
;
525 buf
->vb
.field
= field
;
529 buf
->vb
.state
= VIDEOBUF_PREPARED
;
533 free_buffer(vq
, buf
);
537 static void buffer_queue(struct videobuf_queue
*vq
, struct videobuf_buffer
*vb
)
539 struct viu_buf
*buf
= container_of(vb
, struct viu_buf
, vb
);
540 struct viu_fh
*fh
= vq
->priv_data
;
541 struct viu_dev
*dev
= fh
->dev
;
542 struct viu_dmaqueue
*vidq
= &dev
->vidq
;
543 struct viu_buf
*prev
;
545 if (!list_empty(&vidq
->queued
)) {
546 dprintk(1, "adding vb queue=0x%08lx\n",
547 (unsigned long)&buf
->vb
.queue
);
548 dprintk(1, "vidq pointer 0x%p, queued 0x%p\n",
549 vidq
, &vidq
->queued
);
550 dprintk(1, "dev %p, queued: self %p, next %p, head %p\n",
551 dev
, &vidq
->queued
, vidq
->queued
.next
,
553 list_add_tail(&buf
->vb
.queue
, &vidq
->queued
);
554 buf
->vb
.state
= VIDEOBUF_QUEUED
;
555 dprintk(2, "[%p/%d] buffer_queue - append to queued\n",
557 } else if (list_empty(&vidq
->active
)) {
558 dprintk(1, "adding vb active=0x%08lx\n",
559 (unsigned long)&buf
->vb
.queue
);
560 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
561 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
562 mod_timer(&vidq
->timeout
, jiffies
+BUFFER_TIMEOUT
);
563 dprintk(2, "[%p/%d] buffer_queue - first active\n",
566 buffer_activate(dev
, buf
);
568 dprintk(1, "adding vb queue2=0x%08lx\n",
569 (unsigned long)&buf
->vb
.queue
);
570 prev
= list_entry(vidq
->active
.prev
, struct viu_buf
, vb
.queue
);
571 if (prev
->vb
.width
== buf
->vb
.width
&&
572 prev
->vb
.height
== buf
->vb
.height
&&
573 prev
->fmt
== buf
->fmt
) {
574 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
575 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
576 dprintk(2, "[%p/%d] buffer_queue - append to active\n",
579 list_add_tail(&buf
->vb
.queue
, &vidq
->queued
);
580 buf
->vb
.state
= VIDEOBUF_QUEUED
;
581 dprintk(2, "[%p/%d] buffer_queue - first queued\n",
587 static void buffer_release(struct videobuf_queue
*vq
,
588 struct videobuf_buffer
*vb
)
590 struct viu_buf
*buf
= container_of(vb
, struct viu_buf
, vb
);
591 struct viu_fh
*fh
= vq
->priv_data
;
592 struct viu_dev
*dev
= (struct viu_dev
*)fh
->dev
;
595 free_buffer(vq
, buf
);
598 static struct videobuf_queue_ops viu_video_qops
= {
599 .buf_setup
= buffer_setup
,
600 .buf_prepare
= buffer_prepare
,
601 .buf_queue
= buffer_queue
,
602 .buf_release
= buffer_release
,
606 * IOCTL vidioc handling
608 static int vidioc_querycap(struct file
*file
, void *priv
,
609 struct v4l2_capability
*cap
)
611 strcpy(cap
->driver
, "viu");
612 strcpy(cap
->card
, "viu");
613 cap
->version
= VIU_VERSION
;
614 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
|
616 V4L2_CAP_VIDEO_OVERLAY
|
621 static int vidioc_enum_fmt(struct file
*file
, void *priv
,
622 struct v4l2_fmtdesc
*f
)
624 int index
= f
->index
;
626 if (f
->index
> NUM_FORMATS
)
629 strlcpy(f
->description
, formats
[index
].name
, sizeof(f
->description
));
630 f
->pixelformat
= formats
[index
].fourcc
;
634 static int vidioc_g_fmt_cap(struct file
*file
, void *priv
,
635 struct v4l2_format
*f
)
637 struct viu_fh
*fh
= priv
;
639 f
->fmt
.pix
.width
= fh
->width
;
640 f
->fmt
.pix
.height
= fh
->height
;
641 f
->fmt
.pix
.field
= fh
->vb_vidq
.field
;
642 f
->fmt
.pix
.pixelformat
= fh
->fmt
->pixelformat
;
643 f
->fmt
.pix
.bytesperline
=
644 (f
->fmt
.pix
.width
* fh
->fmt
->depth
) >> 3;
645 f
->fmt
.pix
.sizeimage
= fh
->sizeimage
;
649 static int vidioc_try_fmt_cap(struct file
*file
, void *priv
,
650 struct v4l2_format
*f
)
653 enum v4l2_field field
;
654 unsigned int maxw
, maxh
;
656 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
658 dprintk(1, "Fourcc format (0x%08x) invalid.",
659 f
->fmt
.pix
.pixelformat
);
663 field
= f
->fmt
.pix
.field
;
665 if (field
== V4L2_FIELD_ANY
) {
666 field
= V4L2_FIELD_INTERLACED
;
667 } else if (field
!= V4L2_FIELD_INTERLACED
) {
668 dprintk(1, "Field type invalid.\n");
675 f
->fmt
.pix
.field
= field
;
676 if (f
->fmt
.pix
.height
< 32)
677 f
->fmt
.pix
.height
= 32;
678 if (f
->fmt
.pix
.height
> maxh
)
679 f
->fmt
.pix
.height
= maxh
;
680 if (f
->fmt
.pix
.width
< 48)
681 f
->fmt
.pix
.width
= 48;
682 if (f
->fmt
.pix
.width
> maxw
)
683 f
->fmt
.pix
.width
= maxw
;
684 f
->fmt
.pix
.width
&= ~0x03;
685 f
->fmt
.pix
.bytesperline
=
686 (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
691 static int vidioc_s_fmt_cap(struct file
*file
, void *priv
,
692 struct v4l2_format
*f
)
694 struct viu_fh
*fh
= priv
;
697 ret
= vidioc_try_fmt_cap(file
, fh
, f
);
701 fh
->fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
702 fh
->width
= f
->fmt
.pix
.width
;
703 fh
->height
= f
->fmt
.pix
.height
;
704 fh
->sizeimage
= f
->fmt
.pix
.sizeimage
;
705 fh
->vb_vidq
.field
= f
->fmt
.pix
.field
;
707 dprintk(1, "set to pixelformat '%4.6s'\n", (char *)&fh
->fmt
->name
);
711 static int vidioc_g_fmt_overlay(struct file
*file
, void *priv
,
712 struct v4l2_format
*f
)
714 struct viu_fh
*fh
= priv
;
716 f
->fmt
.win
= fh
->win
;
720 static int verify_preview(struct viu_dev
*dev
, struct v4l2_window
*win
)
722 enum v4l2_field field
;
725 if (dev
->ovbuf
.base
== NULL
)
727 if (dev
->ovfmt
== NULL
)
729 if (win
->w
.width
< 48 || win
->w
.height
< 32)
733 maxw
= dev
->crop_current
.width
;
734 maxh
= dev
->crop_current
.height
;
736 if (field
== V4L2_FIELD_ANY
) {
737 field
= (win
->w
.height
> maxh
/2)
738 ? V4L2_FIELD_INTERLACED
743 case V4L2_FIELD_BOTTOM
:
746 case V4L2_FIELD_INTERLACED
:
753 if (win
->w
.width
> maxw
)
755 if (win
->w
.height
> maxh
)
756 win
->w
.height
= maxh
;
760 inline void viu_activate_overlay(struct viu_reg
*viu_reg
)
762 struct viu_reg
*vr
= viu_reg
;
764 out_be32(&vr
->field_base_addr
, reg_val
.field_base_addr
);
765 out_be32(&vr
->dma_inc
, reg_val
.dma_inc
);
766 out_be32(&vr
->picture_count
, reg_val
.picture_count
);
769 static int viu_start_preview(struct viu_dev
*dev
, struct viu_fh
*fh
)
773 dprintk(1, "%s %dx%d %s\n", __func__
,
774 fh
->win
.w
.width
, fh
->win
.w
.height
, dev
->ovfmt
->name
);
776 reg_val
.status_cfg
= 0;
779 reg_val
.picture_count
= (fh
->win
.w
.height
/ 2) << 16 |
782 /* setup color depth and dma increment */
783 bpp
= dev
->ovfmt
->depth
/ 8;
786 reg_val
.status_cfg
&= ~MODE_32BIT
;
787 reg_val
.dma_inc
= fh
->win
.w
.width
* 2;
790 reg_val
.status_cfg
|= MODE_32BIT
;
791 reg_val
.dma_inc
= fh
->win
.w
.width
* 4;
794 dprintk(0, "device doesn't support color depth(%d)\n",
799 dev
->ovfield
= fh
->win
.field
;
800 if (!V4L2_FIELD_HAS_BOTH(dev
->ovfield
))
803 reg_val
.status_cfg
|= DMA_ACT
| INT_DMA_END_EN
| INT_FIELD_EN
;
805 /* setup the base address of the overlay buffer */
806 reg_val
.field_base_addr
= (u32
)dev
->ovbuf
.base
;
809 viu_activate_overlay(dev
->vr
);
816 static int vidioc_s_fmt_overlay(struct file
*file
, void *priv
,
817 struct v4l2_format
*f
)
819 struct viu_fh
*fh
= priv
;
820 struct viu_dev
*dev
= (struct viu_dev
*)fh
->dev
;
824 err
= verify_preview(dev
, &f
->fmt
.win
);
828 mutex_lock(&dev
->lock
);
829 fh
->win
= f
->fmt
.win
;
831 spin_lock_irqsave(&dev
->slock
, flags
);
832 viu_start_preview(dev
, fh
);
833 spin_unlock_irqrestore(&dev
->slock
, flags
);
834 mutex_unlock(&dev
->lock
);
838 static int vidioc_try_fmt_overlay(struct file
*file
, void *priv
,
839 struct v4l2_format
*f
)
844 int vidioc_g_fbuf(struct file
*file
, void *priv
, struct v4l2_framebuffer
*arg
)
846 struct viu_fh
*fh
= priv
;
847 struct viu_dev
*dev
= fh
->dev
;
848 struct v4l2_framebuffer
*fb
= arg
;
851 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
855 int vidioc_s_fbuf(struct file
*file
, void *priv
, struct v4l2_framebuffer
*arg
)
857 struct viu_fh
*fh
= priv
;
858 struct viu_dev
*dev
= fh
->dev
;
859 struct v4l2_framebuffer
*fb
= arg
;
862 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
866 fmt
= format_by_fourcc(fb
->fmt
.pixelformat
);
873 if (dev
->ovbuf
.fmt
.bytesperline
== 0) {
874 dev
->ovbuf
.fmt
.bytesperline
=
875 dev
->ovbuf
.fmt
.width
* fmt
->depth
/ 8;
880 static int vidioc_reqbufs(struct file
*file
, void *priv
,
881 struct v4l2_requestbuffers
*p
)
883 struct viu_fh
*fh
= priv
;
885 return videobuf_reqbufs(&fh
->vb_vidq
, p
);
888 static int vidioc_querybuf(struct file
*file
, void *priv
,
889 struct v4l2_buffer
*p
)
891 struct viu_fh
*fh
= priv
;
893 return videobuf_querybuf(&fh
->vb_vidq
, p
);
896 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
898 struct viu_fh
*fh
= priv
;
900 return videobuf_qbuf(&fh
->vb_vidq
, p
);
903 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
905 struct viu_fh
*fh
= priv
;
907 return videobuf_dqbuf(&fh
->vb_vidq
, p
,
908 file
->f_flags
& O_NONBLOCK
);
911 static int vidioc_streamon(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
913 struct viu_fh
*fh
= priv
;
915 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
920 viu_start_dma(fh
->dev
);
922 return videobuf_streamon(&fh
->vb_vidq
);
925 static int vidioc_streamoff(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
927 struct viu_fh
*fh
= priv
;
929 if (fh
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
934 viu_stop_dma(fh
->dev
);
936 return videobuf_streamoff(&fh
->vb_vidq
);
939 #define decoder_call(viu, o, f, args...) \
940 v4l2_subdev_call(viu->decoder, o, f, ##args)
942 static int vidioc_querystd(struct file
*file
, void *priv
, v4l2_std_id
*std_id
)
944 struct viu_fh
*fh
= priv
;
946 decoder_call(fh
->dev
, video
, querystd
, std_id
);
950 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id
*id
)
952 struct viu_fh
*fh
= priv
;
955 decoder_call(fh
->dev
, core
, s_std
, *id
);
959 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*std_id
)
961 struct viu_fh
*fh
= priv
;
963 *std_id
= fh
->dev
->std
;
967 /* only one input in this driver */
968 static int vidioc_enum_input(struct file
*file
, void *priv
,
969 struct v4l2_input
*inp
)
971 struct viu_fh
*fh
= priv
;
976 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
977 inp
->std
= fh
->dev
->vdev
->tvnorms
;
978 strcpy(inp
->name
, "Camera");
982 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
988 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
990 struct viu_fh
*fh
= priv
;
995 decoder_call(fh
->dev
, video
, s_routing
, i
, 0, 0);
1000 static int vidioc_queryctrl(struct file
*file
, void *priv
,
1001 struct v4l2_queryctrl
*qc
)
1005 for (i
= 0; i
< ARRAY_SIZE(viu_qctrl
); i
++) {
1006 if (qc
->id
&& qc
->id
== viu_qctrl
[i
].id
) {
1007 memcpy(qc
, &(viu_qctrl
[i
]), sizeof(*qc
));
1014 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
1015 struct v4l2_control
*ctrl
)
1019 for (i
= 0; i
< ARRAY_SIZE(viu_qctrl
); i
++) {
1020 if (ctrl
->id
== viu_qctrl
[i
].id
) {
1021 ctrl
->value
= qctl_regs
[i
];
1027 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
1028 struct v4l2_control
*ctrl
)
1032 for (i
= 0; i
< ARRAY_SIZE(viu_qctrl
); i
++) {
1033 if (ctrl
->id
== viu_qctrl
[i
].id
) {
1034 if (ctrl
->value
< viu_qctrl
[i
].minimum
1035 || ctrl
->value
> viu_qctrl
[i
].maximum
)
1037 qctl_regs
[i
] = ctrl
->value
;
1044 inline void viu_activate_next_buf(struct viu_dev
*dev
,
1045 struct viu_dmaqueue
*viuq
)
1047 struct viu_dmaqueue
*vidq
= viuq
;
1048 struct viu_buf
*buf
;
1050 /* launch another DMA operation for an active/queued buffer */
1051 if (!list_empty(&vidq
->active
)) {
1052 buf
= list_entry(vidq
->active
.next
, struct viu_buf
,
1054 dprintk(1, "start another queued buffer: 0x%p\n", buf
);
1055 buffer_activate(dev
, buf
);
1056 } else if (!list_empty(&vidq
->queued
)) {
1057 buf
= list_entry(vidq
->queued
.next
, struct viu_buf
,
1059 list_del(&buf
->vb
.queue
);
1061 dprintk(1, "start another queued buffer: 0x%p\n", buf
);
1062 list_add_tail(&buf
->vb
.queue
, &vidq
->active
);
1063 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
1064 buffer_activate(dev
, buf
);
1068 inline void viu_default_settings(struct viu_reg
*viu_reg
)
1070 struct viu_reg
*vr
= viu_reg
;
1072 out_be32(&vr
->luminance
, 0x9512A254);
1073 out_be32(&vr
->chroma_r
, 0x03310000);
1074 out_be32(&vr
->chroma_g
, 0x06600F38);
1075 out_be32(&vr
->chroma_b
, 0x00000409);
1076 out_be32(&vr
->alpha
, 0x000000ff);
1077 out_be32(&vr
->req_alarm
, 0x00000090);
1078 dprintk(1, "status reg: 0x%08x, field base: 0x%08x\n",
1079 in_be32(&vr
->status_cfg
), in_be32(&vr
->field_base_addr
));
1082 static void viu_overlay_intr(struct viu_dev
*dev
, u32 status
)
1084 struct viu_reg
*vr
= dev
->vr
;
1086 if (status
& INT_DMA_END_STATUS
)
1089 if (status
& INT_FIELD_STATUS
) {
1090 if (dev
->dma_done
) {
1091 u32 addr
= reg_val
.field_base_addr
;
1094 if (status
& FIELD_NO
)
1095 addr
+= reg_val
.dma_inc
;
1097 out_be32(&vr
->field_base_addr
, addr
);
1098 out_be32(&vr
->dma_inc
, reg_val
.dma_inc
);
1099 out_be32(&vr
->status_cfg
,
1100 (status
& 0xffc0ffff) |
1101 (status
& INT_ALL_STATUS
) |
1102 reg_val
.status_cfg
);
1103 } else if (status
& INT_VSYNC_STATUS
) {
1104 out_be32(&vr
->status_cfg
,
1105 (status
& 0xffc0ffff) |
1106 (status
& INT_ALL_STATUS
) |
1107 reg_val
.status_cfg
);
1112 static void viu_capture_intr(struct viu_dev
*dev
, u32 status
)
1114 struct viu_dmaqueue
*vidq
= &dev
->vidq
;
1115 struct viu_reg
*vr
= dev
->vr
;
1116 struct viu_buf
*buf
;
1121 field_num
= status
& FIELD_NO
;
1122 need_two
= V4L2_FIELD_HAS_BOTH(dev
->capfield
);
1124 if (status
& INT_DMA_END_STATUS
) {
1126 if (((field_num
== 0) && (dev
->field
== 0)) ||
1127 (field_num
&& (dev
->field
== 1)))
1131 if (status
& INT_FIELD_STATUS
) {
1132 dprintk(1, "irq: field %d, done %d\n",
1133 !!field_num
, dma_done
);
1134 if (unlikely(dev
->first
)) {
1135 if (field_num
== 0) {
1137 dprintk(1, "activate first buf\n");
1138 viu_activate_next_buf(dev
, vidq
);
1140 dprintk(1, "wait field 0\n");
1144 /* setup buffer address for next dma operation */
1145 if (!list_empty(&vidq
->active
)) {
1146 u32 addr
= reg_val
.field_base_addr
;
1148 if (field_num
&& need_two
) {
1149 addr
+= reg_val
.dma_inc
;
1150 dprintk(1, "field 1, 0x%lx, dev field %d\n",
1151 (unsigned long)addr
, dev
->field
);
1153 out_be32(&vr
->field_base_addr
, addr
);
1154 out_be32(&vr
->dma_inc
, reg_val
.dma_inc
);
1155 out_be32(&vr
->status_cfg
,
1156 (status
& 0xffc0ffff) |
1157 (status
& INT_ALL_STATUS
) |
1158 reg_val
.status_cfg
);
1163 if (dma_done
&& field_num
&& (dev
->field
== 2)) {
1165 buf
= list_entry(vidq
->active
.next
,
1166 struct viu_buf
, vb
.queue
);
1167 dprintk(1, "viu/0: [%p/%d] 0x%lx/0x%lx: dma complete\n",
1169 (unsigned long)videobuf_to_dma_contig(&buf
->vb
),
1170 (unsigned long)in_be32(&vr
->field_base_addr
));
1172 if (waitqueue_active(&buf
->vb
.done
)) {
1173 list_del(&buf
->vb
.queue
);
1174 do_gettimeofday(&buf
->vb
.ts
);
1175 buf
->vb
.state
= VIDEOBUF_DONE
;
1176 buf
->vb
.field_count
++;
1177 wake_up(&buf
->vb
.done
);
1179 /* activate next dma buffer */
1180 viu_activate_next_buf(dev
, vidq
);
1184 static irqreturn_t
viu_intr(int irq
, void *dev_id
)
1186 struct viu_dev
*dev
= (struct viu_dev
*)dev_id
;
1187 struct viu_reg
*vr
= dev
->vr
;
1191 status
= in_be32(&vr
->status_cfg
);
1193 if (status
& INT_ERROR_STATUS
) {
1194 dev
->irqs
.error_irq
++;
1195 error
= status
& ERR_MASK
;
1197 dprintk(1, "Err: error(%d), times:%d!\n",
1198 error
>> 4, dev
->irqs
.error_irq
);
1199 /* Clear interrupt error bit and error flags */
1200 out_be32(&vr
->status_cfg
,
1201 (status
& 0xffc0ffff) | INT_ERROR_STATUS
);
1204 if (status
& INT_DMA_END_STATUS
) {
1205 dev
->irqs
.dma_end_irq
++;
1207 dprintk(2, "VIU DMA end interrupt times: %d\n",
1208 dev
->irqs
.dma_end_irq
);
1211 if (status
& INT_HSYNC_STATUS
)
1212 dev
->irqs
.hsync_irq
++;
1214 if (status
& INT_FIELD_STATUS
) {
1215 dev
->irqs
.field_irq
++;
1216 dprintk(2, "VIU field interrupt times: %d\n",
1217 dev
->irqs
.field_irq
);
1220 if (status
& INT_VSTART_STATUS
)
1221 dev
->irqs
.vstart_irq
++;
1223 if (status
& INT_VSYNC_STATUS
) {
1224 dev
->irqs
.vsync_irq
++;
1225 dprintk(2, "VIU vsync interrupt times: %d\n",
1226 dev
->irqs
.vsync_irq
);
1229 /* clear all pending irqs */
1230 status
= in_be32(&vr
->status_cfg
);
1231 out_be32(&vr
->status_cfg
,
1232 (status
& 0xffc0ffff) | (status
& INT_ALL_STATUS
));
1234 if (dev
->ovenable
) {
1235 viu_overlay_intr(dev
, status
);
1240 viu_capture_intr(dev
, status
);
1245 * File operations for the device
1247 static int viu_open(struct file
*file
)
1249 struct video_device
*vdev
= video_devdata(file
);
1250 struct viu_dev
*dev
= video_get_drvdata(vdev
);
1253 int minor
= vdev
->minor
;
1257 dprintk(1, "viu: open (minor=%d)\n", minor
);
1260 if (dev
->users
> 1) {
1267 dprintk(1, "open minor=%d type=%s users=%d\n", minor
,
1268 v4l2_type_names
[V4L2_BUF_TYPE_VIDEO_CAPTURE
], dev
->users
);
1270 /* allocate and initialize per filehandle data */
1271 fh
= kzalloc(sizeof(*fh
), GFP_KERNEL
);
1277 file
->private_data
= fh
;
1280 fh
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1281 fh
->fmt
= format_by_fourcc(V4L2_PIX_FMT_RGB32
);
1282 fh
->width
= norm_maxw();
1283 fh
->height
= norm_maxh();
1284 dev
->crop_current
.width
= fh
->width
;
1285 dev
->crop_current
.height
= fh
->height
;
1287 /* Put all controls at a sane state */
1288 for (i
= 0; i
< ARRAY_SIZE(viu_qctrl
); i
++)
1289 qctl_regs
[i
] = viu_qctrl
[i
].default_value
;
1291 dprintk(1, "Open: fh=0x%08lx, dev=0x%08lx, dev->vidq=0x%08lx\n",
1292 (unsigned long)fh
, (unsigned long)dev
,
1293 (unsigned long)&dev
->vidq
);
1294 dprintk(1, "Open: list_empty queued=%d\n",
1295 list_empty(&dev
->vidq
.queued
));
1296 dprintk(1, "Open: list_empty active=%d\n",
1297 list_empty(&dev
->vidq
.active
));
1299 viu_default_settings(vr
);
1301 status_cfg
= in_be32(&vr
->status_cfg
);
1302 out_be32(&vr
->status_cfg
,
1303 status_cfg
& ~(INT_VSYNC_EN
| INT_HSYNC_EN
|
1304 INT_FIELD_EN
| INT_VSTART_EN
|
1305 INT_DMA_END_EN
| INT_ERROR_EN
| INT_ECC_EN
));
1307 status_cfg
= in_be32(&vr
->status_cfg
);
1308 out_be32(&vr
->status_cfg
, status_cfg
| INT_ALL_STATUS
);
1310 spin_lock_init(&fh
->vbq_lock
);
1311 videobuf_queue_dma_contig_init(&fh
->vb_vidq
, &viu_video_qops
,
1312 dev
->dev
, &fh
->vbq_lock
,
1313 fh
->type
, V4L2_FIELD_INTERLACED
,
1314 sizeof(struct viu_buf
), fh
, NULL
);
1318 static ssize_t
viu_read(struct file
*file
, char __user
*data
, size_t count
,
1321 struct viu_fh
*fh
= file
->private_data
;
1322 struct viu_dev
*dev
= fh
->dev
;
1325 dprintk(2, "%s\n", __func__
);
1329 if (fh
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1331 ret
= videobuf_read_stream(&fh
->vb_vidq
, data
, count
,
1332 ppos
, 0, file
->f_flags
& O_NONBLOCK
);
1338 static unsigned int viu_poll(struct file
*file
, struct poll_table_struct
*wait
)
1340 struct viu_fh
*fh
= file
->private_data
;
1341 struct videobuf_queue
*q
= &fh
->vb_vidq
;
1343 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= fh
->type
)
1346 return videobuf_poll_stream(file
, q
, wait
);
1349 static int viu_release(struct file
*file
)
1351 struct viu_fh
*fh
= file
->private_data
;
1352 struct viu_dev
*dev
= fh
->dev
;
1353 int minor
= video_devdata(file
)->minor
;
1356 videobuf_stop(&fh
->vb_vidq
);
1357 videobuf_mmap_free(&fh
->vb_vidq
);
1362 dprintk(1, "close (minor=%d, users=%d)\n",
1367 void viu_reset(struct viu_reg
*reg
)
1369 out_be32(®
->status_cfg
, 0);
1370 out_be32(®
->luminance
, 0x9512a254);
1371 out_be32(®
->chroma_r
, 0x03310000);
1372 out_be32(®
->chroma_g
, 0x06600f38);
1373 out_be32(®
->chroma_b
, 0x00000409);
1374 out_be32(®
->field_base_addr
, 0);
1375 out_be32(®
->dma_inc
, 0);
1376 out_be32(®
->picture_count
, 0x01e002d0);
1377 out_be32(®
->req_alarm
, 0x00000090);
1378 out_be32(®
->alpha
, 0x000000ff);
1381 static int viu_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1383 struct viu_fh
*fh
= file
->private_data
;
1386 dprintk(1, "mmap called, vma=0x%08lx\n", (unsigned long)vma
);
1388 ret
= videobuf_mmap_mapper(&fh
->vb_vidq
, vma
);
1390 dprintk(1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1391 (unsigned long)vma
->vm_start
,
1392 (unsigned long)vma
->vm_end
-(unsigned long)vma
->vm_start
,
1398 static struct v4l2_file_operations viu_fops
= {
1399 .owner
= THIS_MODULE
,
1401 .release
= viu_release
,
1404 .ioctl
= video_ioctl2
, /* V4L2 ioctl handler */
1408 static const struct v4l2_ioctl_ops viu_ioctl_ops
= {
1409 .vidioc_querycap
= vidioc_querycap
,
1410 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt
,
1411 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_cap
,
1412 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_cap
,
1413 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_cap
,
1414 .vidioc_enum_fmt_vid_overlay
= vidioc_enum_fmt
,
1415 .vidioc_g_fmt_vid_overlay
= vidioc_g_fmt_overlay
,
1416 .vidioc_try_fmt_vid_overlay
= vidioc_try_fmt_overlay
,
1417 .vidioc_s_fmt_vid_overlay
= vidioc_s_fmt_overlay
,
1418 .vidioc_g_fbuf
= vidioc_g_fbuf
,
1419 .vidioc_s_fbuf
= vidioc_s_fbuf
,
1420 .vidioc_reqbufs
= vidioc_reqbufs
,
1421 .vidioc_querybuf
= vidioc_querybuf
,
1422 .vidioc_qbuf
= vidioc_qbuf
,
1423 .vidioc_dqbuf
= vidioc_dqbuf
,
1424 .vidioc_g_std
= vidioc_g_std
,
1425 .vidioc_s_std
= vidioc_s_std
,
1426 .vidioc_querystd
= vidioc_querystd
,
1427 .vidioc_enum_input
= vidioc_enum_input
,
1428 .vidioc_g_input
= vidioc_g_input
,
1429 .vidioc_s_input
= vidioc_s_input
,
1430 .vidioc_queryctrl
= vidioc_queryctrl
,
1431 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1432 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1433 .vidioc_streamon
= vidioc_streamon
,
1434 .vidioc_streamoff
= vidioc_streamoff
,
1437 static struct video_device viu_template
= {
1441 .ioctl_ops
= &viu_ioctl_ops
,
1442 .release
= video_device_release
,
1444 .tvnorms
= V4L2_STD_NTSC_M
| V4L2_STD_PAL
,
1445 .current_norm
= V4L2_STD_NTSC_M
,
1448 static int __devinit
viu_of_probe(struct platform_device
*op
)
1450 struct viu_dev
*viu_dev
;
1451 struct video_device
*vdev
;
1453 struct viu_reg __iomem
*viu_regs
;
1454 struct i2c_adapter
*ad
;
1457 ret
= of_address_to_resource(op
->dev
.of_node
, 0, &r
);
1459 dev_err(&op
->dev
, "Can't parse device node resource\n");
1463 viu_irq
= irq_of_parse_and_map(op
->dev
.of_node
, 0);
1464 if (viu_irq
== NO_IRQ
) {
1465 dev_err(&op
->dev
, "Error while mapping the irq\n");
1469 /* request mem region */
1470 if (!devm_request_mem_region(&op
->dev
, r
.start
,
1471 sizeof(struct viu_reg
), DRV_NAME
)) {
1472 dev_err(&op
->dev
, "Error while requesting mem region\n");
1477 /* remap registers */
1478 viu_regs
= devm_ioremap(&op
->dev
, r
.start
, sizeof(struct viu_reg
));
1480 dev_err(&op
->dev
, "Can't map register set\n");
1485 /* Prepare our private structure */
1486 viu_dev
= devm_kzalloc(&op
->dev
, sizeof(struct viu_dev
), GFP_ATOMIC
);
1488 dev_err(&op
->dev
, "Can't allocate private structure\n");
1493 viu_dev
->vr
= viu_regs
;
1494 viu_dev
->irq
= viu_irq
;
1495 viu_dev
->dev
= &op
->dev
;
1497 /* init video dma queues */
1498 INIT_LIST_HEAD(&viu_dev
->vidq
.active
);
1499 INIT_LIST_HEAD(&viu_dev
->vidq
.queued
);
1501 /* initialize locks */
1502 mutex_init(&viu_dev
->lock
);
1504 snprintf(viu_dev
->v4l2_dev
.name
,
1505 sizeof(viu_dev
->v4l2_dev
.name
), "%s", "VIU");
1506 ret
= v4l2_device_register(viu_dev
->dev
, &viu_dev
->v4l2_dev
);
1508 dev_err(&op
->dev
, "v4l2_device_register() failed: %d\n", ret
);
1512 ad
= i2c_get_adapter(0);
1513 viu_dev
->decoder
= v4l2_i2c_new_subdev(&viu_dev
->v4l2_dev
, ad
,
1514 "saa7113", VIU_VIDEO_DECODER_ADDR
, NULL
);
1516 viu_dev
->vidq
.timeout
.function
= viu_vid_timeout
;
1517 viu_dev
->vidq
.timeout
.data
= (unsigned long)viu_dev
;
1518 init_timer(&viu_dev
->vidq
.timeout
);
1521 /* Allocate memory for video device */
1522 vdev
= video_device_alloc();
1528 memcpy(vdev
, &viu_template
, sizeof(viu_template
));
1530 vdev
->v4l2_dev
= &viu_dev
->v4l2_dev
;
1532 viu_dev
->vdev
= vdev
;
1534 video_set_drvdata(viu_dev
->vdev
, viu_dev
);
1536 ret
= video_register_device(viu_dev
->vdev
, VFL_TYPE_GRABBER
, -1);
1538 video_device_release(viu_dev
->vdev
);
1542 /* enable VIU clock */
1543 viu_dev
->clk
= clk_get(&op
->dev
, "viu_clk");
1544 if (IS_ERR(viu_dev
->clk
)) {
1545 dev_err(&op
->dev
, "failed to find the clock module!\n");
1549 clk_enable(viu_dev
->clk
);
1552 /* reset VIU module */
1553 viu_reset(viu_dev
->vr
);
1555 /* install interrupt handler */
1556 if (request_irq(viu_dev
->irq
, viu_intr
, 0, "viu", (void *)viu_dev
)) {
1557 dev_err(&op
->dev
, "Request VIU IRQ failed.\n");
1562 dev_info(&op
->dev
, "Freescale VIU Video Capture Board\n");
1566 clk_disable(viu_dev
->clk
);
1567 clk_put(viu_dev
->clk
);
1569 video_unregister_device(viu_dev
->vdev
);
1571 i2c_put_adapter(ad
);
1572 v4l2_device_unregister(&viu_dev
->v4l2_dev
);
1574 irq_dispose_mapping(viu_irq
);
1578 static int __devexit
viu_of_remove(struct platform_device
*op
)
1580 struct v4l2_device
*v4l2_dev
= dev_get_drvdata(&op
->dev
);
1581 struct viu_dev
*dev
= container_of(v4l2_dev
, struct viu_dev
, v4l2_dev
);
1582 struct v4l2_subdev
*sdev
= list_entry(v4l2_dev
->subdevs
.next
,
1583 struct v4l2_subdev
, list
);
1584 struct i2c_client
*client
= v4l2_get_subdevdata(sdev
);
1586 free_irq(dev
->irq
, (void *)dev
);
1587 irq_dispose_mapping(dev
->irq
);
1589 clk_disable(dev
->clk
);
1592 video_unregister_device(dev
->vdev
);
1593 i2c_put_adapter(client
->adapter
);
1594 v4l2_device_unregister(&dev
->v4l2_dev
);
1599 static int viu_suspend(struct platform_device
*op
, pm_message_t state
)
1601 struct v4l2_device
*v4l2_dev
= dev_get_drvdata(&op
->dev
);
1602 struct viu_dev
*dev
= container_of(v4l2_dev
, struct viu_dev
, v4l2_dev
);
1604 clk_disable(dev
->clk
);
1608 static int viu_resume(struct platform_device
*op
)
1610 struct v4l2_device
*v4l2_dev
= dev_get_drvdata(&op
->dev
);
1611 struct viu_dev
*dev
= container_of(v4l2_dev
, struct viu_dev
, v4l2_dev
);
1613 clk_enable(dev
->clk
);
1619 * Initialization and module stuff
1621 static struct of_device_id mpc512x_viu_of_match
[] = {
1623 .compatible
= "fsl,mpc5121-viu",
1627 MODULE_DEVICE_TABLE(of
, mpc512x_viu_of_match
);
1629 static struct platform_driver viu_of_platform_driver
= {
1630 .probe
= viu_of_probe
,
1631 .remove
= __devexit_p(viu_of_remove
),
1633 .suspend
= viu_suspend
,
1634 .resume
= viu_resume
,
1638 .owner
= THIS_MODULE
,
1639 .of_match_table
= mpc512x_viu_of_match
,
1643 static int __init
viu_init(void)
1645 return platform_driver_register(&viu_of_platform_driver
);
1648 static void __exit
viu_exit(void)
1650 platform_driver_unregister(&viu_of_platform_driver
);
1653 module_init(viu_init
);
1654 module_exit(viu_exit
);
1656 MODULE_DESCRIPTION("Freescale Video-In(VIU)");
1657 MODULE_AUTHOR("Hongjun Chen");
1658 MODULE_LICENSE("GPL");