4 * Copyright (C) 2005-2010 Texas Instruments.
6 * This file is licensed under the terms of the GNU General Public License
7 * version 2. This program is licensed "as is" without any warranty of any
8 * kind, whether express or implied.
10 * Leveraged code from the OMAP2 camera driver
11 * Video-for-Linux (Version 2) camera capture driver for
12 * the OMAP24xx camera controller.
14 * Author: Andy Lowe (source@mvista.com)
16 * Copyright (C) 2004 MontaVista Software, Inc.
17 * Copyright (C) 2010 Texas Instruments.
20 * 20-APR-2006 Khasim Modified VRFB based Rotation,
21 * The image data is always read from 0 degree
23 * to the virtual space of desired rotation angle
24 * 4-DEC-2006 Jian Changed to support better memory management
26 * 17-Nov-2008 Hardik Changed driver to use video_ioctl2
28 * 23-Feb-2010 Vaibhav H Modified to use new DSS2 interface
32 #include <linux/init.h>
33 #include <linux/module.h>
34 #include <linux/vmalloc.h>
35 #include <linux/sched.h>
36 #include <linux/types.h>
37 #include <linux/platform_device.h>
38 #include <linux/irq.h>
39 #include <linux/videodev2.h>
40 #include <linux/dma-mapping.h>
41 #include <linux/slab.h>
43 #include <media/videobuf-dma-contig.h>
44 #include <media/v4l2-device.h>
45 #include <media/v4l2-ioctl.h>
49 #include <plat/vrfb.h>
50 #include <video/omapdss.h>
52 #include "omap_voutlib.h"
53 #include "omap_voutdef.h"
54 #include "omap_vout_vrfb.h"
56 MODULE_AUTHOR("Texas Instruments");
57 MODULE_DESCRIPTION("OMAP Video for Linux Video out driver");
58 MODULE_LICENSE("GPL");
60 /* Driver Configuration macros */
61 #define VOUT_NAME "omap_vout"
63 enum omap_vout_channels
{
68 static struct videobuf_queue_ops video_vbq_ops
;
69 /* Variables configurable through module params*/
70 static u32 video1_numbuffers
= 3;
71 static u32 video2_numbuffers
= 3;
72 static u32 video1_bufsize
= OMAP_VOUT_MAX_BUF_SIZE
;
73 static u32 video2_bufsize
= OMAP_VOUT_MAX_BUF_SIZE
;
74 static bool vid1_static_vrfb_alloc
;
75 static bool vid2_static_vrfb_alloc
;
78 /* Module parameters */
79 module_param(video1_numbuffers
, uint
, S_IRUGO
);
80 MODULE_PARM_DESC(video1_numbuffers
,
81 "Number of buffers to be allocated at init time for Video1 device.");
83 module_param(video2_numbuffers
, uint
, S_IRUGO
);
84 MODULE_PARM_DESC(video2_numbuffers
,
85 "Number of buffers to be allocated at init time for Video2 device.");
87 module_param(video1_bufsize
, uint
, S_IRUGO
);
88 MODULE_PARM_DESC(video1_bufsize
,
89 "Size of the buffer to be allocated for video1 device");
91 module_param(video2_bufsize
, uint
, S_IRUGO
);
92 MODULE_PARM_DESC(video2_bufsize
,
93 "Size of the buffer to be allocated for video2 device");
95 module_param(vid1_static_vrfb_alloc
, bool, S_IRUGO
);
96 MODULE_PARM_DESC(vid1_static_vrfb_alloc
,
97 "Static allocation of the VRFB buffer for video1 device");
99 module_param(vid2_static_vrfb_alloc
, bool, S_IRUGO
);
100 MODULE_PARM_DESC(vid2_static_vrfb_alloc
,
101 "Static allocation of the VRFB buffer for video2 device");
103 module_param(debug
, bool, S_IRUGO
);
104 MODULE_PARM_DESC(debug
, "Debug level (0-1)");
106 /* list of image formats supported by OMAP2 video pipelines */
107 static const struct v4l2_fmtdesc omap_formats
[] = {
109 /* Note: V4L2 defines RGB565 as:
112 * g2 g1 g0 r4 r3 r2 r1 r0 b4 b3 b2 b1 b0 g5 g4 g3
114 * We interpret RGB565 as:
117 * g2 g1 g0 b4 b3 b2 b1 b0 r4 r3 r2 r1 r0 g5 g4 g3
119 .description
= "RGB565, le",
120 .pixelformat
= V4L2_PIX_FMT_RGB565
,
123 /* Note: V4L2 defines RGB32 as: RGB-8-8-8-8 we use
124 * this for RGB24 unpack mode, the last 8 bits are ignored
126 .description
= "RGB32, le",
127 .pixelformat
= V4L2_PIX_FMT_RGB32
,
130 /* Note: V4L2 defines RGB24 as: RGB-8-8-8 we use
131 * this for RGB24 packed mode
134 .description
= "RGB24, le",
135 .pixelformat
= V4L2_PIX_FMT_RGB24
,
138 .description
= "YUYV (YUV 4:2:2), packed",
139 .pixelformat
= V4L2_PIX_FMT_YUYV
,
142 .description
= "UYVY, packed",
143 .pixelformat
= V4L2_PIX_FMT_UYVY
,
147 #define NUM_OUTPUT_FORMATS (ARRAY_SIZE(omap_formats))
152 static int omap_vout_try_format(struct v4l2_pix_format
*pix
)
156 pix
->height
= clamp(pix
->height
, (u32
)VID_MIN_HEIGHT
,
157 (u32
)VID_MAX_HEIGHT
);
158 pix
->width
= clamp(pix
->width
, (u32
)VID_MIN_WIDTH
, (u32
)VID_MAX_WIDTH
);
160 for (ifmt
= 0; ifmt
< NUM_OUTPUT_FORMATS
; ifmt
++) {
161 if (pix
->pixelformat
== omap_formats
[ifmt
].pixelformat
)
165 if (ifmt
== NUM_OUTPUT_FORMATS
)
168 pix
->pixelformat
= omap_formats
[ifmt
].pixelformat
;
169 pix
->field
= V4L2_FIELD_ANY
;
172 switch (pix
->pixelformat
) {
173 case V4L2_PIX_FMT_YUYV
:
174 case V4L2_PIX_FMT_UYVY
:
176 pix
->colorspace
= V4L2_COLORSPACE_JPEG
;
179 case V4L2_PIX_FMT_RGB565
:
180 case V4L2_PIX_FMT_RGB565X
:
181 pix
->colorspace
= V4L2_COLORSPACE_SRGB
;
184 case V4L2_PIX_FMT_RGB24
:
185 pix
->colorspace
= V4L2_COLORSPACE_SRGB
;
188 case V4L2_PIX_FMT_RGB32
:
189 case V4L2_PIX_FMT_BGR32
:
190 pix
->colorspace
= V4L2_COLORSPACE_SRGB
;
194 pix
->bytesperline
= pix
->width
* bpp
;
195 pix
->sizeimage
= pix
->bytesperline
* pix
->height
;
201 * omap_vout_uservirt_to_phys: This inline function is used to convert user
202 * space virtual address to physical address.
204 static u32
omap_vout_uservirt_to_phys(u32 virtp
)
206 unsigned long physp
= 0;
207 struct vm_area_struct
*vma
;
208 struct mm_struct
*mm
= current
->mm
;
210 vma
= find_vma(mm
, virtp
);
211 /* For kernel direct-mapped memory, take the easy way */
212 if (virtp
>= PAGE_OFFSET
) {
213 physp
= virt_to_phys((void *) virtp
);
214 } else if (vma
&& (vma
->vm_flags
& VM_IO
) && vma
->vm_pgoff
) {
215 /* this will catch, kernel-allocated, mmaped-to-usermode
217 physp
= (vma
->vm_pgoff
<< PAGE_SHIFT
) + (virtp
- vma
->vm_start
);
219 /* otherwise, use get_user_pages() for general userland pages */
220 int res
, nr_pages
= 1;
222 down_read(¤t
->mm
->mmap_sem
);
224 res
= get_user_pages(current
, current
->mm
, virtp
, nr_pages
, 1,
226 up_read(¤t
->mm
->mmap_sem
);
228 if (res
== nr_pages
) {
229 physp
= __pa(page_address(&pages
[0]) +
230 (virtp
& ~PAGE_MASK
));
232 printk(KERN_WARNING VOUT_NAME
233 "get_user_pages failed\n");
242 * Free the V4L2 buffers
244 void omap_vout_free_buffers(struct omap_vout_device
*vout
)
248 /* Allocate memory for the buffers */
249 numbuffers
= (vout
->vid
) ? video2_numbuffers
: video1_numbuffers
;
250 vout
->buffer_size
= (vout
->vid
) ? video2_bufsize
: video1_bufsize
;
252 for (i
= 0; i
< numbuffers
; i
++) {
253 omap_vout_free_buffer(vout
->buf_virt_addr
[i
],
255 vout
->buf_phy_addr
[i
] = 0;
256 vout
->buf_virt_addr
[i
] = 0;
261 * Convert V4L2 rotation to DSS rotation
262 * V4L2 understand 0, 90, 180, 270.
263 * Convert to 0, 1, 2 and 3 respectively for DSS
265 static int v4l2_rot_to_dss_rot(int v4l2_rotation
,
266 enum dss_rotation
*rotation
, bool mirror
)
270 switch (v4l2_rotation
) {
272 *rotation
= dss_rotation_90_degree
;
275 *rotation
= dss_rotation_180_degree
;
278 *rotation
= dss_rotation_270_degree
;
281 *rotation
= dss_rotation_0_degree
;
289 static int omap_vout_calculate_offset(struct omap_vout_device
*vout
)
291 struct omapvideo_info
*ovid
;
292 struct v4l2_rect
*crop
= &vout
->crop
;
293 struct v4l2_pix_format
*pix
= &vout
->pix
;
294 int *cropped_offset
= &vout
->cropped_offset
;
295 int ps
= 2, line_length
= 0;
297 ovid
= &vout
->vid_info
;
299 if (ovid
->rotation_type
== VOUT_ROT_VRFB
) {
300 omap_vout_calculate_vrfb_offset(vout
);
302 vout
->line_length
= line_length
= pix
->width
;
304 if (V4L2_PIX_FMT_YUYV
== pix
->pixelformat
||
305 V4L2_PIX_FMT_UYVY
== pix
->pixelformat
)
307 else if (V4L2_PIX_FMT_RGB32
== pix
->pixelformat
)
309 else if (V4L2_PIX_FMT_RGB24
== pix
->pixelformat
)
314 *cropped_offset
= (line_length
* ps
) *
315 crop
->top
+ crop
->left
* ps
;
318 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
, "%s Offset:%x\n",
319 __func__
, vout
->cropped_offset
);
325 * Convert V4L2 pixel format to DSS pixel format
327 static int video_mode_to_dss_mode(struct omap_vout_device
*vout
)
329 struct omap_overlay
*ovl
;
330 struct omapvideo_info
*ovid
;
331 struct v4l2_pix_format
*pix
= &vout
->pix
;
332 enum omap_color_mode mode
;
334 ovid
= &vout
->vid_info
;
335 ovl
= ovid
->overlays
[0];
337 switch (pix
->pixelformat
) {
340 case V4L2_PIX_FMT_YUYV
:
341 mode
= OMAP_DSS_COLOR_YUV2
;
343 case V4L2_PIX_FMT_UYVY
:
344 mode
= OMAP_DSS_COLOR_UYVY
;
346 case V4L2_PIX_FMT_RGB565
:
347 mode
= OMAP_DSS_COLOR_RGB16
;
349 case V4L2_PIX_FMT_RGB24
:
350 mode
= OMAP_DSS_COLOR_RGB24P
;
352 case V4L2_PIX_FMT_RGB32
:
353 mode
= (ovl
->id
== OMAP_DSS_VIDEO1
) ?
354 OMAP_DSS_COLOR_RGB24U
: OMAP_DSS_COLOR_ARGB32
;
356 case V4L2_PIX_FMT_BGR32
:
357 mode
= OMAP_DSS_COLOR_RGBX32
;
368 static int omapvid_setup_overlay(struct omap_vout_device
*vout
,
369 struct omap_overlay
*ovl
, int posx
, int posy
, int outw
,
373 struct omap_overlay_info info
;
374 int cropheight
, cropwidth
, pixheight
, pixwidth
;
376 if ((ovl
->caps
& OMAP_DSS_OVL_CAP_SCALE
) == 0 &&
377 (outw
!= vout
->pix
.width
|| outh
!= vout
->pix
.height
)) {
382 vout
->dss_mode
= video_mode_to_dss_mode(vout
);
383 if (vout
->dss_mode
== -EINVAL
) {
388 /* Setup the input plane parameters according to
389 * rotation value selected.
391 if (is_rotation_90_or_270(vout
)) {
392 cropheight
= vout
->crop
.width
;
393 cropwidth
= vout
->crop
.height
;
394 pixheight
= vout
->pix
.width
;
395 pixwidth
= vout
->pix
.height
;
397 cropheight
= vout
->crop
.height
;
398 cropwidth
= vout
->crop
.width
;
399 pixheight
= vout
->pix
.height
;
400 pixwidth
= vout
->pix
.width
;
403 ovl
->get_overlay_info(ovl
, &info
);
405 info
.width
= cropwidth
;
406 info
.height
= cropheight
;
407 info
.color_mode
= vout
->dss_mode
;
408 info
.mirror
= vout
->mirror
;
411 info
.out_width
= outw
;
412 info
.out_height
= outh
;
413 info
.global_alpha
= vout
->win
.global_alpha
;
414 if (!is_rotation_enabled(vout
)) {
416 info
.rotation_type
= OMAP_DSS_ROT_DMA
;
417 info
.screen_width
= pixwidth
;
419 info
.rotation
= vout
->rotation
;
420 info
.rotation_type
= OMAP_DSS_ROT_VRFB
;
421 info
.screen_width
= 2048;
424 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
,
425 "%s enable=%d addr=%x width=%d\n height=%d color_mode=%d\n"
426 "rotation=%d mirror=%d posx=%d posy=%d out_width = %d \n"
427 "out_height=%d rotation_type=%d screen_width=%d\n",
428 __func__
, ovl
->is_enabled(ovl
), info
.paddr
, info
.width
, info
.height
,
429 info
.color_mode
, info
.rotation
, info
.mirror
, info
.pos_x
,
430 info
.pos_y
, info
.out_width
, info
.out_height
, info
.rotation_type
,
433 ret
= ovl
->set_overlay_info(ovl
, &info
);
440 v4l2_warn(&vout
->vid_dev
->v4l2_dev
, "setup_overlay failed\n");
445 * Initialize the overlay structure
447 static int omapvid_init(struct omap_vout_device
*vout
, u32 addr
)
450 struct v4l2_window
*win
;
451 struct omap_overlay
*ovl
;
452 int posx
, posy
, outw
, outh
, temp
;
453 struct omap_video_timings
*timing
;
454 struct omapvideo_info
*ovid
= &vout
->vid_info
;
457 for (i
= 0; i
< ovid
->num_overlays
; i
++) {
458 struct omap_dss_device
*dssdev
;
460 ovl
= ovid
->overlays
[i
];
461 dssdev
= ovl
->get_device(ovl
);
466 timing
= &dssdev
->panel
.timings
;
469 outh
= win
->w
.height
;
470 switch (vout
->rotation
) {
471 case dss_rotation_90_degree
:
472 /* Invert the height and width for 90
473 * and 270 degree rotation
478 posy
= (timing
->y_res
- win
->w
.width
) - win
->w
.left
;
482 case dss_rotation_180_degree
:
483 posx
= (timing
->x_res
- win
->w
.width
) - win
->w
.left
;
484 posy
= (timing
->y_res
- win
->w
.height
) - win
->w
.top
;
487 case dss_rotation_270_degree
:
492 posx
= (timing
->x_res
- win
->w
.height
) - win
->w
.top
;
501 ret
= omapvid_setup_overlay(vout
, ovl
, posx
, posy
,
504 goto omapvid_init_err
;
509 v4l2_warn(&vout
->vid_dev
->v4l2_dev
, "apply_changes failed\n");
514 * Apply the changes set the go bit of DSS
516 static int omapvid_apply_changes(struct omap_vout_device
*vout
)
519 struct omap_overlay
*ovl
;
520 struct omapvideo_info
*ovid
= &vout
->vid_info
;
522 for (i
= 0; i
< ovid
->num_overlays
; i
++) {
523 struct omap_dss_device
*dssdev
;
525 ovl
= ovid
->overlays
[i
];
526 dssdev
= ovl
->get_device(ovl
);
529 ovl
->manager
->apply(ovl
->manager
);
535 static int omapvid_handle_interlace_display(struct omap_vout_device
*vout
,
536 unsigned int irqstatus
, struct timeval timevalue
)
540 if (vout
->first_int
) {
545 if (irqstatus
& DISPC_IRQ_EVSYNC_ODD
)
547 else if (irqstatus
& DISPC_IRQ_EVSYNC_EVEN
)
553 if (fid
!= vout
->field_id
) {
555 vout
->field_id
= fid
;
556 } else if (0 == fid
) {
557 if (vout
->cur_frm
== vout
->next_frm
)
560 vout
->cur_frm
->ts
= timevalue
;
561 vout
->cur_frm
->state
= VIDEOBUF_DONE
;
562 wake_up_interruptible(&vout
->cur_frm
->done
);
563 vout
->cur_frm
= vout
->next_frm
;
565 if (list_empty(&vout
->dma_queue
) ||
566 (vout
->cur_frm
!= vout
->next_frm
))
570 return vout
->field_id
;
575 static void omap_vout_isr(void *arg
, unsigned int irqstatus
)
577 int ret
, fid
, mgr_id
;
579 struct omap_overlay
*ovl
;
580 struct timeval timevalue
;
581 struct omapvideo_info
*ovid
;
582 struct omap_dss_device
*cur_display
;
583 struct omap_vout_device
*vout
= (struct omap_vout_device
*)arg
;
585 if (!vout
->streaming
)
588 ovid
= &vout
->vid_info
;
589 ovl
= ovid
->overlays
[0];
591 mgr_id
= ovl
->manager
->id
;
593 /* get the display device attached to the overlay */
594 cur_display
= ovl
->get_device(ovl
);
599 spin_lock(&vout
->vbq_lock
);
600 do_gettimeofday(&timevalue
);
602 switch (cur_display
->type
) {
603 case OMAP_DISPLAY_TYPE_DSI
:
604 case OMAP_DISPLAY_TYPE_DPI
:
605 if (mgr_id
== OMAP_DSS_CHANNEL_LCD
)
606 irq
= DISPC_IRQ_VSYNC
;
607 else if (mgr_id
== OMAP_DSS_CHANNEL_LCD2
)
608 irq
= DISPC_IRQ_VSYNC2
;
612 if (!(irqstatus
& irq
))
615 case OMAP_DISPLAY_TYPE_VENC
:
616 fid
= omapvid_handle_interlace_display(vout
, irqstatus
,
621 case OMAP_DISPLAY_TYPE_HDMI
:
622 if (!(irqstatus
& DISPC_IRQ_EVSYNC_EVEN
))
629 if (!vout
->first_int
&& (vout
->cur_frm
!= vout
->next_frm
)) {
630 vout
->cur_frm
->ts
= timevalue
;
631 vout
->cur_frm
->state
= VIDEOBUF_DONE
;
632 wake_up_interruptible(&vout
->cur_frm
->done
);
633 vout
->cur_frm
= vout
->next_frm
;
637 if (list_empty(&vout
->dma_queue
))
640 vout
->next_frm
= list_entry(vout
->dma_queue
.next
,
641 struct videobuf_buffer
, queue
);
642 list_del(&vout
->next_frm
->queue
);
644 vout
->next_frm
->state
= VIDEOBUF_ACTIVE
;
646 addr
= (unsigned long) vout
->queued_buf_addr
[vout
->next_frm
->i
]
647 + vout
->cropped_offset
;
649 /* First save the configuration in ovelray structure */
650 ret
= omapvid_init(vout
, addr
);
652 printk(KERN_ERR VOUT_NAME
653 "failed to set overlay info\n");
654 /* Enable the pipeline and set the Go bit */
655 ret
= omapvid_apply_changes(vout
);
657 printk(KERN_ERR VOUT_NAME
"failed to change mode\n");
660 spin_unlock(&vout
->vbq_lock
);
663 /* Video buffer call backs */
666 * Buffer setup function is called by videobuf layer when REQBUF ioctl is
667 * called. This is used to setup buffers and return size and count of
668 * buffers allocated. After the call to this buffer, videobuf layer will
669 * setup buffer queue depending on the size and count of buffers
671 static int omap_vout_buffer_setup(struct videobuf_queue
*q
, unsigned int *count
,
674 int startindex
= 0, i
, j
;
675 u32 phy_addr
= 0, virt_addr
= 0;
676 struct omap_vout_device
*vout
= q
->priv_data
;
677 struct omapvideo_info
*ovid
= &vout
->vid_info
;
678 int vid_max_buf_size
;
683 vid_max_buf_size
= vout
->vid
== OMAP_VIDEO1
? video1_bufsize
:
686 if (V4L2_BUF_TYPE_VIDEO_OUTPUT
!= q
->type
)
689 startindex
= (vout
->vid
== OMAP_VIDEO1
) ?
690 video1_numbuffers
: video2_numbuffers
;
691 if (V4L2_MEMORY_MMAP
== vout
->memory
&& *count
< startindex
)
694 if (ovid
->rotation_type
== VOUT_ROT_VRFB
) {
695 if (omap_vout_vrfb_buffer_setup(vout
, count
, startindex
))
699 if (V4L2_MEMORY_MMAP
!= vout
->memory
)
702 /* Now allocated the V4L2 buffers */
703 *size
= PAGE_ALIGN(vout
->pix
.width
* vout
->pix
.height
* vout
->bpp
);
704 startindex
= (vout
->vid
== OMAP_VIDEO1
) ?
705 video1_numbuffers
: video2_numbuffers
;
707 /* Check the size of the buffer */
708 if (*size
> vid_max_buf_size
) {
709 v4l2_err(&vout
->vid_dev
->v4l2_dev
,
710 "buffer allocation mismatch [%u] [%u]\n",
711 *size
, vout
->buffer_size
);
715 for (i
= startindex
; i
< *count
; i
++) {
716 vout
->buffer_size
= *size
;
718 virt_addr
= omap_vout_alloc_buffer(vout
->buffer_size
,
721 if (ovid
->rotation_type
== VOUT_ROT_NONE
) {
724 if (!is_rotation_enabled(vout
))
726 /* Free the VRFB buffers if no space for V4L2 buffers */
727 for (j
= i
; j
< *count
; j
++) {
728 omap_vout_free_buffer(
729 vout
->smsshado_virt_addr
[j
],
730 vout
->smsshado_size
);
731 vout
->smsshado_virt_addr
[j
] = 0;
732 vout
->smsshado_phy_addr
[j
] = 0;
736 vout
->buf_virt_addr
[i
] = virt_addr
;
737 vout
->buf_phy_addr
[i
] = phy_addr
;
739 *count
= vout
->buffer_allocated
= i
;
745 * Free the V4L2 buffers additionally allocated than default
748 static void omap_vout_free_extra_buffers(struct omap_vout_device
*vout
)
750 int num_buffers
= 0, i
;
752 num_buffers
= (vout
->vid
== OMAP_VIDEO1
) ?
753 video1_numbuffers
: video2_numbuffers
;
755 for (i
= num_buffers
; i
< vout
->buffer_allocated
; i
++) {
756 if (vout
->buf_virt_addr
[i
])
757 omap_vout_free_buffer(vout
->buf_virt_addr
[i
],
760 vout
->buf_virt_addr
[i
] = 0;
761 vout
->buf_phy_addr
[i
] = 0;
763 vout
->buffer_allocated
= num_buffers
;
767 * This function will be called when VIDIOC_QBUF ioctl is called.
768 * It prepare buffers before give out for the display. This function
769 * converts user space virtual address into physical address if userptr memory
770 * exchange mechanism is used. If rotation is enabled, it copies entire
771 * buffer into VRFB memory space before giving it to the DSS.
773 static int omap_vout_buffer_prepare(struct videobuf_queue
*q
,
774 struct videobuf_buffer
*vb
,
775 enum v4l2_field field
)
777 struct omap_vout_device
*vout
= q
->priv_data
;
778 struct omapvideo_info
*ovid
= &vout
->vid_info
;
780 if (VIDEOBUF_NEEDS_INIT
== vb
->state
) {
781 vb
->width
= vout
->pix
.width
;
782 vb
->height
= vout
->pix
.height
;
783 vb
->size
= vb
->width
* vb
->height
* vout
->bpp
;
786 vb
->state
= VIDEOBUF_PREPARED
;
787 /* if user pointer memory mechanism is used, get the physical
788 * address of the buffer
790 if (V4L2_MEMORY_USERPTR
== vb
->memory
) {
793 /* Physical address */
794 vout
->queued_buf_addr
[vb
->i
] = (u8
*)
795 omap_vout_uservirt_to_phys(vb
->baddr
);
800 addr
= (unsigned long) vout
->buf_virt_addr
[vb
->i
];
801 size
= (unsigned long) vb
->size
;
803 dma_addr
= dma_map_single(vout
->vid_dev
->v4l2_dev
.dev
, (void *) addr
,
804 size
, DMA_TO_DEVICE
);
805 if (dma_mapping_error(vout
->vid_dev
->v4l2_dev
.dev
, dma_addr
))
806 v4l2_err(&vout
->vid_dev
->v4l2_dev
, "dma_map_single failed\n");
808 vout
->queued_buf_addr
[vb
->i
] = (u8
*)vout
->buf_phy_addr
[vb
->i
];
811 if (ovid
->rotation_type
== VOUT_ROT_VRFB
)
812 return omap_vout_prepare_vrfb(vout
, vb
);
818 * Buffer queue function will be called from the videobuf layer when _QBUF
819 * ioctl is called. It is used to enqueue buffer, which is ready to be
822 static void omap_vout_buffer_queue(struct videobuf_queue
*q
,
823 struct videobuf_buffer
*vb
)
825 struct omap_vout_device
*vout
= q
->priv_data
;
827 /* Driver is also maintainig a queue. So enqueue buffer in the driver
829 list_add_tail(&vb
->queue
, &vout
->dma_queue
);
831 vb
->state
= VIDEOBUF_QUEUED
;
835 * Buffer release function is called from videobuf layer to release buffer
836 * which are already allocated
838 static void omap_vout_buffer_release(struct videobuf_queue
*q
,
839 struct videobuf_buffer
*vb
)
841 struct omap_vout_device
*vout
= q
->priv_data
;
843 vb
->state
= VIDEOBUF_NEEDS_INIT
;
845 if (V4L2_MEMORY_MMAP
!= vout
->memory
)
852 static unsigned int omap_vout_poll(struct file
*file
,
853 struct poll_table_struct
*wait
)
855 struct omap_vout_device
*vout
= file
->private_data
;
856 struct videobuf_queue
*q
= &vout
->vbq
;
858 return videobuf_poll_stream(file
, q
, wait
);
861 static void omap_vout_vm_open(struct vm_area_struct
*vma
)
863 struct omap_vout_device
*vout
= vma
->vm_private_data
;
865 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
,
866 "vm_open [vma=%08lx-%08lx]\n", vma
->vm_start
, vma
->vm_end
);
870 static void omap_vout_vm_close(struct vm_area_struct
*vma
)
872 struct omap_vout_device
*vout
= vma
->vm_private_data
;
874 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
,
875 "vm_close [vma=%08lx-%08lx]\n", vma
->vm_start
, vma
->vm_end
);
879 static struct vm_operations_struct omap_vout_vm_ops
= {
880 .open
= omap_vout_vm_open
,
881 .close
= omap_vout_vm_close
,
884 static int omap_vout_mmap(struct file
*file
, struct vm_area_struct
*vma
)
888 unsigned long start
= vma
->vm_start
;
889 unsigned long size
= (vma
->vm_end
- vma
->vm_start
);
890 struct omap_vout_device
*vout
= file
->private_data
;
891 struct videobuf_queue
*q
= &vout
->vbq
;
893 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
,
894 " %s pgoff=0x%lx, start=0x%lx, end=0x%lx\n", __func__
,
895 vma
->vm_pgoff
, vma
->vm_start
, vma
->vm_end
);
897 /* look for the buffer to map */
898 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
899 if (NULL
== q
->bufs
[i
])
901 if (V4L2_MEMORY_MMAP
!= q
->bufs
[i
]->memory
)
903 if (q
->bufs
[i
]->boff
== (vma
->vm_pgoff
<< PAGE_SHIFT
))
907 if (VIDEO_MAX_FRAME
== i
) {
908 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
,
909 "offset invalid [offset=0x%lx]\n",
910 (vma
->vm_pgoff
<< PAGE_SHIFT
));
913 /* Check the size of the buffer */
914 if (size
> vout
->buffer_size
) {
915 v4l2_err(&vout
->vid_dev
->v4l2_dev
,
916 "insufficient memory [%lu] [%u]\n",
917 size
, vout
->buffer_size
);
921 q
->bufs
[i
]->baddr
= vma
->vm_start
;
923 vma
->vm_flags
|= VM_DONTEXPAND
| VM_DONTDUMP
;
924 vma
->vm_page_prot
= pgprot_writecombine(vma
->vm_page_prot
);
925 vma
->vm_ops
= &omap_vout_vm_ops
;
926 vma
->vm_private_data
= (void *) vout
;
927 pos
= (void *)vout
->buf_virt_addr
[i
];
928 vma
->vm_pgoff
= virt_to_phys((void *)pos
) >> PAGE_SHIFT
;
931 pfn
= virt_to_phys((void *) pos
) >> PAGE_SHIFT
;
932 if (remap_pfn_range(vma
, start
, pfn
, PAGE_SIZE
, PAGE_SHARED
))
939 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
, "Exiting %s\n", __func__
);
944 static int omap_vout_release(struct file
*file
)
947 struct videobuf_queue
*q
;
948 struct omapvideo_info
*ovid
;
949 struct omap_vout_device
*vout
= file
->private_data
;
951 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
, "Entering %s\n", __func__
);
952 ovid
= &vout
->vid_info
;
958 /* Disable all the overlay managers connected with this interface */
959 for (i
= 0; i
< ovid
->num_overlays
; i
++) {
960 struct omap_overlay
*ovl
= ovid
->overlays
[i
];
961 struct omap_dss_device
*dssdev
= ovl
->get_device(ovl
);
966 /* Turn off the pipeline */
967 ret
= omapvid_apply_changes(vout
);
969 v4l2_warn(&vout
->vid_dev
->v4l2_dev
,
970 "Unable to apply changes\n");
972 /* Free all buffers */
973 omap_vout_free_extra_buffers(vout
);
975 /* Free the VRFB buffers only if they are allocated
976 * during reqbufs. Don't free if init time allocated
978 if (ovid
->rotation_type
== VOUT_ROT_VRFB
) {
979 if (!vout
->vrfb_static_allocation
)
980 omap_vout_free_vrfb_buffers(vout
);
982 videobuf_mmap_free(q
);
984 /* Even if apply changes fails we should continue
985 freeing allocated memory */
986 if (vout
->streaming
) {
989 mask
= DISPC_IRQ_VSYNC
| DISPC_IRQ_EVSYNC_EVEN
|
990 DISPC_IRQ_EVSYNC_ODD
| DISPC_IRQ_VSYNC2
;
991 omap_dispc_unregister_isr(omap_vout_isr
, vout
, mask
);
994 videobuf_streamoff(q
);
995 videobuf_queue_cancel(q
);
998 if (vout
->mmap_count
!= 0)
999 vout
->mmap_count
= 0;
1002 file
->private_data
= NULL
;
1004 if (vout
->buffer_allocated
)
1005 videobuf_mmap_free(q
);
1007 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
, "Exiting %s\n", __func__
);
1011 static int omap_vout_open(struct file
*file
)
1013 struct videobuf_queue
*q
;
1014 struct omap_vout_device
*vout
= NULL
;
1016 vout
= video_drvdata(file
);
1017 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
, "Entering %s\n", __func__
);
1022 /* for now, we only support single open */
1028 file
->private_data
= vout
;
1029 vout
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1032 video_vbq_ops
.buf_setup
= omap_vout_buffer_setup
;
1033 video_vbq_ops
.buf_prepare
= omap_vout_buffer_prepare
;
1034 video_vbq_ops
.buf_release
= omap_vout_buffer_release
;
1035 video_vbq_ops
.buf_queue
= omap_vout_buffer_queue
;
1036 spin_lock_init(&vout
->vbq_lock
);
1038 videobuf_queue_dma_contig_init(q
, &video_vbq_ops
, q
->dev
,
1039 &vout
->vbq_lock
, vout
->type
, V4L2_FIELD_NONE
,
1040 sizeof(struct videobuf_buffer
), vout
, NULL
);
1042 v4l2_dbg(1, debug
, &vout
->vid_dev
->v4l2_dev
, "Exiting %s\n", __func__
);
1049 static int vidioc_querycap(struct file
*file
, void *fh
,
1050 struct v4l2_capability
*cap
)
1052 struct omap_vout_device
*vout
= fh
;
1054 strlcpy(cap
->driver
, VOUT_NAME
, sizeof(cap
->driver
));
1055 strlcpy(cap
->card
, vout
->vfd
->name
, sizeof(cap
->card
));
1056 cap
->bus_info
[0] = '\0';
1057 cap
->capabilities
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_OUTPUT
|
1058 V4L2_CAP_VIDEO_OUTPUT_OVERLAY
;
1063 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *fh
,
1064 struct v4l2_fmtdesc
*fmt
)
1066 int index
= fmt
->index
;
1068 if (index
>= NUM_OUTPUT_FORMATS
)
1071 fmt
->flags
= omap_formats
[index
].flags
;
1072 strlcpy(fmt
->description
, omap_formats
[index
].description
,
1073 sizeof(fmt
->description
));
1074 fmt
->pixelformat
= omap_formats
[index
].pixelformat
;
1079 static int vidioc_g_fmt_vid_out(struct file
*file
, void *fh
,
1080 struct v4l2_format
*f
)
1082 struct omap_vout_device
*vout
= fh
;
1084 f
->fmt
.pix
= vout
->pix
;
1089 static int vidioc_try_fmt_vid_out(struct file
*file
, void *fh
,
1090 struct v4l2_format
*f
)
1092 struct omap_overlay
*ovl
;
1093 struct omapvideo_info
*ovid
;
1094 struct omap_video_timings
*timing
;
1095 struct omap_vout_device
*vout
= fh
;
1096 struct omap_dss_device
*dssdev
;
1098 ovid
= &vout
->vid_info
;
1099 ovl
= ovid
->overlays
[0];
1100 /* get the display device attached to the overlay */
1101 dssdev
= ovl
->get_device(ovl
);
1106 timing
= &dssdev
->panel
.timings
;
1108 vout
->fbuf
.fmt
.height
= timing
->y_res
;
1109 vout
->fbuf
.fmt
.width
= timing
->x_res
;
1111 omap_vout_try_format(&f
->fmt
.pix
);
1115 static int vidioc_s_fmt_vid_out(struct file
*file
, void *fh
,
1116 struct v4l2_format
*f
)
1119 struct omap_overlay
*ovl
;
1120 struct omapvideo_info
*ovid
;
1121 struct omap_video_timings
*timing
;
1122 struct omap_vout_device
*vout
= fh
;
1123 struct omap_dss_device
*dssdev
;
1125 if (vout
->streaming
)
1128 mutex_lock(&vout
->lock
);
1130 ovid
= &vout
->vid_info
;
1131 ovl
= ovid
->overlays
[0];
1132 dssdev
= ovl
->get_device(ovl
);
1134 /* get the display device attached to the overlay */
1137 goto s_fmt_vid_out_exit
;
1139 timing
= &dssdev
->panel
.timings
;
1141 /* We dont support RGB24-packed mode if vrfb rotation
1143 if ((is_rotation_enabled(vout
)) &&
1144 f
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_RGB24
) {
1146 goto s_fmt_vid_out_exit
;
1149 /* get the framebuffer parameters */
1151 if (is_rotation_90_or_270(vout
)) {
1152 vout
->fbuf
.fmt
.height
= timing
->x_res
;
1153 vout
->fbuf
.fmt
.width
= timing
->y_res
;
1155 vout
->fbuf
.fmt
.height
= timing
->y_res
;
1156 vout
->fbuf
.fmt
.width
= timing
->x_res
;
1159 /* change to samller size is OK */
1161 bpp
= omap_vout_try_format(&f
->fmt
.pix
);
1162 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.width
* f
->fmt
.pix
.height
* bpp
;
1164 /* try & set the new output format */
1166 vout
->pix
= f
->fmt
.pix
;
1169 /* If YUYV then vrfb bpp is 2, for others its 1 */
1170 if (V4L2_PIX_FMT_YUYV
== vout
->pix
.pixelformat
||
1171 V4L2_PIX_FMT_UYVY
== vout
->pix
.pixelformat
)
1174 /* set default crop and win */
1175 omap_vout_new_format(&vout
->pix
, &vout
->fbuf
, &vout
->crop
, &vout
->win
);
1177 /* Save the changes in the overlay strcuture */
1178 ret
= omapvid_init(vout
, 0);
1180 v4l2_err(&vout
->vid_dev
->v4l2_dev
, "failed to change mode\n");
1181 goto s_fmt_vid_out_exit
;
1187 mutex_unlock(&vout
->lock
);
1191 static int vidioc_try_fmt_vid_overlay(struct file
*file
, void *fh
,
1192 struct v4l2_format
*f
)
1195 struct omap_vout_device
*vout
= fh
;
1196 struct omap_overlay
*ovl
;
1197 struct omapvideo_info
*ovid
;
1198 struct v4l2_window
*win
= &f
->fmt
.win
;
1200 ovid
= &vout
->vid_info
;
1201 ovl
= ovid
->overlays
[0];
1203 ret
= omap_vout_try_window(&vout
->fbuf
, win
);
1206 if ((ovl
->caps
& OMAP_DSS_OVL_CAP_GLOBAL_ALPHA
) == 0)
1207 win
->global_alpha
= 255;
1209 win
->global_alpha
= f
->fmt
.win
.global_alpha
;
1215 static int vidioc_s_fmt_vid_overlay(struct file
*file
, void *fh
,
1216 struct v4l2_format
*f
)
1219 struct omap_overlay
*ovl
;
1220 struct omapvideo_info
*ovid
;
1221 struct omap_vout_device
*vout
= fh
;
1222 struct v4l2_window
*win
= &f
->fmt
.win
;
1224 mutex_lock(&vout
->lock
);
1225 ovid
= &vout
->vid_info
;
1226 ovl
= ovid
->overlays
[0];
1228 ret
= omap_vout_new_window(&vout
->crop
, &vout
->win
, &vout
->fbuf
, win
);
1230 /* Video1 plane does not support global alpha on OMAP3 */
1231 if ((ovl
->caps
& OMAP_DSS_OVL_CAP_GLOBAL_ALPHA
) == 0)
1232 vout
->win
.global_alpha
= 255;
1234 vout
->win
.global_alpha
= f
->fmt
.win
.global_alpha
;
1236 vout
->win
.chromakey
= f
->fmt
.win
.chromakey
;
1238 mutex_unlock(&vout
->lock
);
1242 static int vidioc_enum_fmt_vid_overlay(struct file
*file
, void *fh
,
1243 struct v4l2_fmtdesc
*fmt
)
1245 int index
= fmt
->index
;
1247 if (index
>= NUM_OUTPUT_FORMATS
)
1250 fmt
->flags
= omap_formats
[index
].flags
;
1251 strlcpy(fmt
->description
, omap_formats
[index
].description
,
1252 sizeof(fmt
->description
));
1253 fmt
->pixelformat
= omap_formats
[index
].pixelformat
;
1257 static int vidioc_g_fmt_vid_overlay(struct file
*file
, void *fh
,
1258 struct v4l2_format
*f
)
1261 struct omap_overlay
*ovl
;
1262 struct omapvideo_info
*ovid
;
1263 struct omap_vout_device
*vout
= fh
;
1264 struct omap_overlay_manager_info info
;
1265 struct v4l2_window
*win
= &f
->fmt
.win
;
1267 ovid
= &vout
->vid_info
;
1268 ovl
= ovid
->overlays
[0];
1270 win
->w
= vout
->win
.w
;
1271 win
->field
= vout
->win
.field
;
1272 win
->global_alpha
= vout
->win
.global_alpha
;
1274 if (ovl
->manager
&& ovl
->manager
->get_manager_info
) {
1275 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1276 key_value
= info
.trans_key
;
1278 win
->chromakey
= key_value
;
1282 static int vidioc_cropcap(struct file
*file
, void *fh
,
1283 struct v4l2_cropcap
*cropcap
)
1285 struct omap_vout_device
*vout
= fh
;
1286 struct v4l2_pix_format
*pix
= &vout
->pix
;
1288 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1291 /* Width and height are always even */
1292 cropcap
->bounds
.width
= pix
->width
& ~1;
1293 cropcap
->bounds
.height
= pix
->height
& ~1;
1295 omap_vout_default_crop(&vout
->pix
, &vout
->fbuf
, &cropcap
->defrect
);
1296 cropcap
->pixelaspect
.numerator
= 1;
1297 cropcap
->pixelaspect
.denominator
= 1;
1301 static int vidioc_g_crop(struct file
*file
, void *fh
, struct v4l2_crop
*crop
)
1303 struct omap_vout_device
*vout
= fh
;
1305 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1307 crop
->c
= vout
->crop
;
1311 static int vidioc_s_crop(struct file
*file
, void *fh
, const struct v4l2_crop
*crop
)
1314 struct omap_vout_device
*vout
= fh
;
1315 struct omapvideo_info
*ovid
;
1316 struct omap_overlay
*ovl
;
1317 struct omap_video_timings
*timing
;
1318 struct omap_dss_device
*dssdev
;
1320 if (vout
->streaming
)
1323 mutex_lock(&vout
->lock
);
1324 ovid
= &vout
->vid_info
;
1325 ovl
= ovid
->overlays
[0];
1326 /* get the display device attached to the overlay */
1327 dssdev
= ovl
->get_device(ovl
);
1334 timing
= &dssdev
->panel
.timings
;
1336 if (is_rotation_90_or_270(vout
)) {
1337 vout
->fbuf
.fmt
.height
= timing
->x_res
;
1338 vout
->fbuf
.fmt
.width
= timing
->y_res
;
1340 vout
->fbuf
.fmt
.height
= timing
->y_res
;
1341 vout
->fbuf
.fmt
.width
= timing
->x_res
;
1344 if (crop
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1345 ret
= omap_vout_new_crop(&vout
->pix
, &vout
->crop
, &vout
->win
,
1346 &vout
->fbuf
, &crop
->c
);
1349 mutex_unlock(&vout
->lock
);
1353 static int vidioc_queryctrl(struct file
*file
, void *fh
,
1354 struct v4l2_queryctrl
*ctrl
)
1359 case V4L2_CID_ROTATE
:
1360 ret
= v4l2_ctrl_query_fill(ctrl
, 0, 270, 90, 0);
1362 case V4L2_CID_BG_COLOR
:
1363 ret
= v4l2_ctrl_query_fill(ctrl
, 0, 0xFFFFFF, 1, 0);
1365 case V4L2_CID_VFLIP
:
1366 ret
= v4l2_ctrl_query_fill(ctrl
, 0, 1, 1, 0);
1369 ctrl
->name
[0] = '\0';
1375 static int vidioc_g_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*ctrl
)
1378 struct omap_vout_device
*vout
= fh
;
1381 case V4L2_CID_ROTATE
:
1382 ctrl
->value
= vout
->control
[0].value
;
1384 case V4L2_CID_BG_COLOR
:
1386 struct omap_overlay_manager_info info
;
1387 struct omap_overlay
*ovl
;
1389 ovl
= vout
->vid_info
.overlays
[0];
1390 if (!ovl
->manager
|| !ovl
->manager
->get_manager_info
) {
1395 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1396 ctrl
->value
= info
.default_color
;
1399 case V4L2_CID_VFLIP
:
1400 ctrl
->value
= vout
->control
[2].value
;
1408 static int vidioc_s_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*a
)
1411 struct omap_vout_device
*vout
= fh
;
1414 case V4L2_CID_ROTATE
:
1416 struct omapvideo_info
*ovid
;
1417 int rotation
= a
->value
;
1419 ovid
= &vout
->vid_info
;
1421 mutex_lock(&vout
->lock
);
1422 if (rotation
&& ovid
->rotation_type
== VOUT_ROT_NONE
) {
1423 mutex_unlock(&vout
->lock
);
1428 if (rotation
&& vout
->pix
.pixelformat
== V4L2_PIX_FMT_RGB24
) {
1429 mutex_unlock(&vout
->lock
);
1434 if (v4l2_rot_to_dss_rot(rotation
, &vout
->rotation
,
1436 mutex_unlock(&vout
->lock
);
1441 vout
->control
[0].value
= rotation
;
1442 mutex_unlock(&vout
->lock
);
1445 case V4L2_CID_BG_COLOR
:
1447 struct omap_overlay
*ovl
;
1448 unsigned int color
= a
->value
;
1449 struct omap_overlay_manager_info info
;
1451 ovl
= vout
->vid_info
.overlays
[0];
1453 mutex_lock(&vout
->lock
);
1454 if (!ovl
->manager
|| !ovl
->manager
->get_manager_info
) {
1455 mutex_unlock(&vout
->lock
);
1460 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1461 info
.default_color
= color
;
1462 if (ovl
->manager
->set_manager_info(ovl
->manager
, &info
)) {
1463 mutex_unlock(&vout
->lock
);
1468 vout
->control
[1].value
= color
;
1469 mutex_unlock(&vout
->lock
);
1472 case V4L2_CID_VFLIP
:
1474 struct omap_overlay
*ovl
;
1475 struct omapvideo_info
*ovid
;
1476 unsigned int mirror
= a
->value
;
1478 ovid
= &vout
->vid_info
;
1479 ovl
= ovid
->overlays
[0];
1481 mutex_lock(&vout
->lock
);
1482 if (mirror
&& ovid
->rotation_type
== VOUT_ROT_NONE
) {
1483 mutex_unlock(&vout
->lock
);
1488 if (mirror
&& vout
->pix
.pixelformat
== V4L2_PIX_FMT_RGB24
) {
1489 mutex_unlock(&vout
->lock
);
1493 vout
->mirror
= mirror
;
1494 vout
->control
[2].value
= mirror
;
1495 mutex_unlock(&vout
->lock
);
1504 static int vidioc_reqbufs(struct file
*file
, void *fh
,
1505 struct v4l2_requestbuffers
*req
)
1508 unsigned int i
, num_buffers
= 0;
1509 struct omap_vout_device
*vout
= fh
;
1510 struct videobuf_queue
*q
= &vout
->vbq
;
1512 if ((req
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
) || (req
->count
< 0))
1514 /* if memory is not mmp or userptr
1516 if ((V4L2_MEMORY_MMAP
!= req
->memory
) &&
1517 (V4L2_MEMORY_USERPTR
!= req
->memory
))
1520 mutex_lock(&vout
->lock
);
1521 /* Cannot be requested when streaming is on */
1522 if (vout
->streaming
) {
1527 /* If buffers are already allocated free them */
1528 if (q
->bufs
[0] && (V4L2_MEMORY_MMAP
== q
->bufs
[0]->memory
)) {
1529 if (vout
->mmap_count
) {
1533 num_buffers
= (vout
->vid
== OMAP_VIDEO1
) ?
1534 video1_numbuffers
: video2_numbuffers
;
1535 for (i
= num_buffers
; i
< vout
->buffer_allocated
; i
++) {
1536 omap_vout_free_buffer(vout
->buf_virt_addr
[i
],
1538 vout
->buf_virt_addr
[i
] = 0;
1539 vout
->buf_phy_addr
[i
] = 0;
1541 vout
->buffer_allocated
= num_buffers
;
1542 videobuf_mmap_free(q
);
1543 } else if (q
->bufs
[0] && (V4L2_MEMORY_USERPTR
== q
->bufs
[0]->memory
)) {
1544 if (vout
->buffer_allocated
) {
1545 videobuf_mmap_free(q
);
1546 for (i
= 0; i
< vout
->buffer_allocated
; i
++) {
1550 vout
->buffer_allocated
= 0;
1554 /*store the memory type in data structure */
1555 vout
->memory
= req
->memory
;
1557 INIT_LIST_HEAD(&vout
->dma_queue
);
1559 /* call videobuf_reqbufs api */
1560 ret
= videobuf_reqbufs(q
, req
);
1564 vout
->buffer_allocated
= req
->count
;
1567 mutex_unlock(&vout
->lock
);
1571 static int vidioc_querybuf(struct file
*file
, void *fh
,
1572 struct v4l2_buffer
*b
)
1574 struct omap_vout_device
*vout
= fh
;
1576 return videobuf_querybuf(&vout
->vbq
, b
);
1579 static int vidioc_qbuf(struct file
*file
, void *fh
,
1580 struct v4l2_buffer
*buffer
)
1582 struct omap_vout_device
*vout
= fh
;
1583 struct videobuf_queue
*q
= &vout
->vbq
;
1585 if ((V4L2_BUF_TYPE_VIDEO_OUTPUT
!= buffer
->type
) ||
1586 (buffer
->index
>= vout
->buffer_allocated
) ||
1587 (q
->bufs
[buffer
->index
]->memory
!= buffer
->memory
)) {
1590 if (V4L2_MEMORY_USERPTR
== buffer
->memory
) {
1591 if ((buffer
->length
< vout
->pix
.sizeimage
) ||
1592 (0 == buffer
->m
.userptr
)) {
1597 if ((is_rotation_enabled(vout
)) &&
1598 vout
->vrfb_dma_tx
.req_status
== DMA_CHAN_NOT_ALLOTED
) {
1599 v4l2_warn(&vout
->vid_dev
->v4l2_dev
,
1600 "DMA Channel not allocated for Rotation\n");
1604 return videobuf_qbuf(q
, buffer
);
1607 static int vidioc_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
1609 struct omap_vout_device
*vout
= fh
;
1610 struct videobuf_queue
*q
= &vout
->vbq
;
1615 struct videobuf_buffer
*vb
;
1617 vb
= q
->bufs
[b
->index
];
1619 if (!vout
->streaming
)
1622 if (file
->f_flags
& O_NONBLOCK
)
1623 /* Call videobuf_dqbuf for non blocking mode */
1624 ret
= videobuf_dqbuf(q
, (struct v4l2_buffer
*)b
, 1);
1626 /* Call videobuf_dqbuf for blocking mode */
1627 ret
= videobuf_dqbuf(q
, (struct v4l2_buffer
*)b
, 0);
1629 addr
= (unsigned long) vout
->buf_phy_addr
[vb
->i
];
1630 size
= (unsigned long) vb
->size
;
1631 dma_unmap_single(vout
->vid_dev
->v4l2_dev
.dev
, addr
,
1632 size
, DMA_TO_DEVICE
);
1636 static int vidioc_streamon(struct file
*file
, void *fh
, enum v4l2_buf_type i
)
1639 u32 addr
= 0, mask
= 0;
1640 struct omap_vout_device
*vout
= fh
;
1641 struct videobuf_queue
*q
= &vout
->vbq
;
1642 struct omapvideo_info
*ovid
= &vout
->vid_info
;
1644 mutex_lock(&vout
->lock
);
1646 if (vout
->streaming
) {
1651 ret
= videobuf_streamon(q
);
1655 if (list_empty(&vout
->dma_queue
)) {
1660 /* Get the next frame from the buffer queue */
1661 vout
->next_frm
= vout
->cur_frm
= list_entry(vout
->dma_queue
.next
,
1662 struct videobuf_buffer
, queue
);
1663 /* Remove buffer from the buffer queue */
1664 list_del(&vout
->cur_frm
->queue
);
1665 /* Mark state of the current frame to active */
1666 vout
->cur_frm
->state
= VIDEOBUF_ACTIVE
;
1667 /* Initialize field_id and started member */
1670 /* set flag here. Next QBUF will start DMA */
1671 vout
->streaming
= 1;
1673 vout
->first_int
= 1;
1675 if (omap_vout_calculate_offset(vout
)) {
1679 addr
= (unsigned long) vout
->queued_buf_addr
[vout
->cur_frm
->i
]
1680 + vout
->cropped_offset
;
1682 mask
= DISPC_IRQ_VSYNC
| DISPC_IRQ_EVSYNC_EVEN
| DISPC_IRQ_EVSYNC_ODD
1685 omap_dispc_register_isr(omap_vout_isr
, vout
, mask
);
1687 for (j
= 0; j
< ovid
->num_overlays
; j
++) {
1688 struct omap_overlay
*ovl
= ovid
->overlays
[j
];
1690 if (ovl
->get_device(ovl
)) {
1691 struct omap_overlay_info info
;
1692 ovl
->get_overlay_info(ovl
, &info
);
1694 if (ovl
->set_overlay_info(ovl
, &info
)) {
1701 /* First save the configuration in ovelray structure */
1702 ret
= omapvid_init(vout
, addr
);
1704 v4l2_err(&vout
->vid_dev
->v4l2_dev
,
1705 "failed to set overlay info\n");
1706 /* Enable the pipeline and set the Go bit */
1707 ret
= omapvid_apply_changes(vout
);
1709 v4l2_err(&vout
->vid_dev
->v4l2_dev
, "failed to change mode\n");
1711 for (j
= 0; j
< ovid
->num_overlays
; j
++) {
1712 struct omap_overlay
*ovl
= ovid
->overlays
[j
];
1713 struct omap_dss_device
*dssdev
= ovl
->get_device(ovl
);
1716 ret
= ovl
->enable(ovl
);
1726 ret
= videobuf_streamoff(q
);
1728 mutex_unlock(&vout
->lock
);
1732 static int vidioc_streamoff(struct file
*file
, void *fh
, enum v4l2_buf_type i
)
1736 struct omap_vout_device
*vout
= fh
;
1737 struct omapvideo_info
*ovid
= &vout
->vid_info
;
1739 if (!vout
->streaming
)
1742 vout
->streaming
= 0;
1743 mask
= DISPC_IRQ_VSYNC
| DISPC_IRQ_EVSYNC_EVEN
| DISPC_IRQ_EVSYNC_ODD
1746 omap_dispc_unregister_isr(omap_vout_isr
, vout
, mask
);
1748 for (j
= 0; j
< ovid
->num_overlays
; j
++) {
1749 struct omap_overlay
*ovl
= ovid
->overlays
[j
];
1750 struct omap_dss_device
*dssdev
= ovl
->get_device(ovl
);
1756 /* Turn of the pipeline */
1757 ret
= omapvid_apply_changes(vout
);
1759 v4l2_err(&vout
->vid_dev
->v4l2_dev
, "failed to change mode in"
1762 INIT_LIST_HEAD(&vout
->dma_queue
);
1763 ret
= videobuf_streamoff(&vout
->vbq
);
1768 static int vidioc_s_fbuf(struct file
*file
, void *fh
,
1769 const struct v4l2_framebuffer
*a
)
1772 struct omap_overlay
*ovl
;
1773 struct omapvideo_info
*ovid
;
1774 struct omap_vout_device
*vout
= fh
;
1775 struct omap_overlay_manager_info info
;
1776 enum omap_dss_trans_key_type key_type
= OMAP_DSS_COLOR_KEY_GFX_DST
;
1778 ovid
= &vout
->vid_info
;
1779 ovl
= ovid
->overlays
[0];
1781 /* OMAP DSS doesn't support Source and Destination color
1783 if ((a
->flags
& V4L2_FBUF_FLAG_SRC_CHROMAKEY
) &&
1784 (a
->flags
& V4L2_FBUF_FLAG_CHROMAKEY
))
1786 /* OMAP DSS Doesn't support the Destination color key
1787 and alpha blending together */
1788 if ((a
->flags
& V4L2_FBUF_FLAG_CHROMAKEY
) &&
1789 (a
->flags
& V4L2_FBUF_FLAG_LOCAL_ALPHA
))
1792 if ((a
->flags
& V4L2_FBUF_FLAG_SRC_CHROMAKEY
)) {
1793 vout
->fbuf
.flags
|= V4L2_FBUF_FLAG_SRC_CHROMAKEY
;
1794 key_type
= OMAP_DSS_COLOR_KEY_VID_SRC
;
1796 vout
->fbuf
.flags
&= ~V4L2_FBUF_FLAG_SRC_CHROMAKEY
;
1798 if ((a
->flags
& V4L2_FBUF_FLAG_CHROMAKEY
)) {
1799 vout
->fbuf
.flags
|= V4L2_FBUF_FLAG_CHROMAKEY
;
1800 key_type
= OMAP_DSS_COLOR_KEY_GFX_DST
;
1802 vout
->fbuf
.flags
&= ~V4L2_FBUF_FLAG_CHROMAKEY
;
1804 if (a
->flags
& (V4L2_FBUF_FLAG_CHROMAKEY
|
1805 V4L2_FBUF_FLAG_SRC_CHROMAKEY
))
1809 if (ovl
->manager
&& ovl
->manager
->get_manager_info
&&
1810 ovl
->manager
->set_manager_info
) {
1812 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1813 info
.trans_enabled
= enable
;
1814 info
.trans_key_type
= key_type
;
1815 info
.trans_key
= vout
->win
.chromakey
;
1817 if (ovl
->manager
->set_manager_info(ovl
->manager
, &info
))
1820 if (a
->flags
& V4L2_FBUF_FLAG_LOCAL_ALPHA
) {
1821 vout
->fbuf
.flags
|= V4L2_FBUF_FLAG_LOCAL_ALPHA
;
1824 vout
->fbuf
.flags
&= ~V4L2_FBUF_FLAG_LOCAL_ALPHA
;
1827 if (ovl
->manager
&& ovl
->manager
->get_manager_info
&&
1828 ovl
->manager
->set_manager_info
) {
1829 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1830 /* enable this only if there is no zorder cap */
1831 if ((ovl
->caps
& OMAP_DSS_OVL_CAP_ZORDER
) == 0)
1832 info
.partial_alpha_enabled
= enable
;
1833 if (ovl
->manager
->set_manager_info(ovl
->manager
, &info
))
1840 static int vidioc_g_fbuf(struct file
*file
, void *fh
,
1841 struct v4l2_framebuffer
*a
)
1843 struct omap_overlay
*ovl
;
1844 struct omapvideo_info
*ovid
;
1845 struct omap_vout_device
*vout
= fh
;
1846 struct omap_overlay_manager_info info
;
1848 ovid
= &vout
->vid_info
;
1849 ovl
= ovid
->overlays
[0];
1851 /* The video overlay must stay within the framebuffer and can't be
1852 positioned independently. */
1853 a
->flags
= V4L2_FBUF_FLAG_OVERLAY
;
1854 a
->capability
= V4L2_FBUF_CAP_LOCAL_ALPHA
| V4L2_FBUF_CAP_CHROMAKEY
1855 | V4L2_FBUF_CAP_SRC_CHROMAKEY
;
1857 if (ovl
->manager
&& ovl
->manager
->get_manager_info
) {
1858 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1859 if (info
.trans_key_type
== OMAP_DSS_COLOR_KEY_VID_SRC
)
1860 a
->flags
|= V4L2_FBUF_FLAG_SRC_CHROMAKEY
;
1861 if (info
.trans_key_type
== OMAP_DSS_COLOR_KEY_GFX_DST
)
1862 a
->flags
|= V4L2_FBUF_FLAG_CHROMAKEY
;
1864 if (ovl
->manager
&& ovl
->manager
->get_manager_info
) {
1865 ovl
->manager
->get_manager_info(ovl
->manager
, &info
);
1866 if (info
.partial_alpha_enabled
)
1867 a
->flags
|= V4L2_FBUF_FLAG_LOCAL_ALPHA
;
1873 static const struct v4l2_ioctl_ops vout_ioctl_ops
= {
1874 .vidioc_querycap
= vidioc_querycap
,
1875 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
1876 .vidioc_g_fmt_vid_out
= vidioc_g_fmt_vid_out
,
1877 .vidioc_try_fmt_vid_out
= vidioc_try_fmt_vid_out
,
1878 .vidioc_s_fmt_vid_out
= vidioc_s_fmt_vid_out
,
1879 .vidioc_queryctrl
= vidioc_queryctrl
,
1880 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1881 .vidioc_s_fbuf
= vidioc_s_fbuf
,
1882 .vidioc_g_fbuf
= vidioc_g_fbuf
,
1883 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1884 .vidioc_try_fmt_vid_overlay
= vidioc_try_fmt_vid_overlay
,
1885 .vidioc_s_fmt_vid_overlay
= vidioc_s_fmt_vid_overlay
,
1886 .vidioc_enum_fmt_vid_overlay
= vidioc_enum_fmt_vid_overlay
,
1887 .vidioc_g_fmt_vid_overlay
= vidioc_g_fmt_vid_overlay
,
1888 .vidioc_cropcap
= vidioc_cropcap
,
1889 .vidioc_g_crop
= vidioc_g_crop
,
1890 .vidioc_s_crop
= vidioc_s_crop
,
1891 .vidioc_reqbufs
= vidioc_reqbufs
,
1892 .vidioc_querybuf
= vidioc_querybuf
,
1893 .vidioc_qbuf
= vidioc_qbuf
,
1894 .vidioc_dqbuf
= vidioc_dqbuf
,
1895 .vidioc_streamon
= vidioc_streamon
,
1896 .vidioc_streamoff
= vidioc_streamoff
,
1899 static const struct v4l2_file_operations omap_vout_fops
= {
1900 .owner
= THIS_MODULE
,
1901 .poll
= omap_vout_poll
,
1902 .unlocked_ioctl
= video_ioctl2
,
1903 .mmap
= omap_vout_mmap
,
1904 .open
= omap_vout_open
,
1905 .release
= omap_vout_release
,
1908 /* Init functions used during driver initialization */
1909 /* Initial setup of video_data */
1910 static int __init
omap_vout_setup_video_data(struct omap_vout_device
*vout
)
1912 struct video_device
*vfd
;
1913 struct v4l2_pix_format
*pix
;
1914 struct v4l2_control
*control
;
1915 struct omap_overlay
*ovl
= vout
->vid_info
.overlays
[0];
1916 struct omap_dss_device
*display
= ovl
->get_device(ovl
);
1918 /* set the default pix */
1921 /* Set the default picture of QVGA */
1922 pix
->width
= QQVGA_WIDTH
;
1923 pix
->height
= QQVGA_HEIGHT
;
1925 /* Default pixel format is RGB 5-6-5 */
1926 pix
->pixelformat
= V4L2_PIX_FMT_RGB565
;
1927 pix
->field
= V4L2_FIELD_ANY
;
1928 pix
->bytesperline
= pix
->width
* 2;
1929 pix
->sizeimage
= pix
->bytesperline
* pix
->height
;
1931 pix
->colorspace
= V4L2_COLORSPACE_JPEG
;
1933 vout
->bpp
= RGB565_BPP
;
1934 vout
->fbuf
.fmt
.width
= display
->panel
.timings
.x_res
;
1935 vout
->fbuf
.fmt
.height
= display
->panel
.timings
.y_res
;
1937 /* Set the data structures for the overlay parameters*/
1938 vout
->win
.global_alpha
= 255;
1939 vout
->fbuf
.flags
= 0;
1940 vout
->fbuf
.capability
= V4L2_FBUF_CAP_LOCAL_ALPHA
|
1941 V4L2_FBUF_CAP_SRC_CHROMAKEY
| V4L2_FBUF_CAP_CHROMAKEY
;
1942 vout
->win
.chromakey
= 0;
1944 omap_vout_new_format(pix
, &vout
->fbuf
, &vout
->crop
, &vout
->win
);
1946 /*Initialize the control variables for
1947 rotation, flipping and background color. */
1948 control
= vout
->control
;
1949 control
[0].id
= V4L2_CID_ROTATE
;
1950 control
[0].value
= 0;
1953 vout
->control
[2].id
= V4L2_CID_HFLIP
;
1954 vout
->control
[2].value
= 0;
1955 if (vout
->vid_info
.rotation_type
== VOUT_ROT_VRFB
)
1958 control
[1].id
= V4L2_CID_BG_COLOR
;
1959 control
[1].value
= 0;
1961 /* initialize the video_device struct */
1962 vfd
= vout
->vfd
= video_device_alloc();
1965 printk(KERN_ERR VOUT_NAME
": could not allocate"
1966 " video device struct\n");
1969 vfd
->release
= video_device_release
;
1970 vfd
->ioctl_ops
= &vout_ioctl_ops
;
1972 strlcpy(vfd
->name
, VOUT_NAME
, sizeof(vfd
->name
));
1974 vfd
->fops
= &omap_vout_fops
;
1975 vfd
->v4l2_dev
= &vout
->vid_dev
->v4l2_dev
;
1976 vfd
->vfl_dir
= VFL_DIR_TX
;
1977 mutex_init(&vout
->lock
);
1984 /* Setup video buffers */
1985 static int __init
omap_vout_setup_video_bufs(struct platform_device
*pdev
,
1990 struct omapvideo_info
*ovid
;
1991 struct omap_vout_device
*vout
;
1992 struct v4l2_device
*v4l2_dev
= platform_get_drvdata(pdev
);
1993 struct omap2video_device
*vid_dev
=
1994 container_of(v4l2_dev
, struct omap2video_device
, v4l2_dev
);
1996 vout
= vid_dev
->vouts
[vid_num
];
1997 ovid
= &vout
->vid_info
;
1999 numbuffers
= (vid_num
== 0) ? video1_numbuffers
: video2_numbuffers
;
2000 vout
->buffer_size
= (vid_num
== 0) ? video1_bufsize
: video2_bufsize
;
2001 dev_info(&pdev
->dev
, "Buffer Size = %d\n", vout
->buffer_size
);
2003 for (i
= 0; i
< numbuffers
; i
++) {
2004 vout
->buf_virt_addr
[i
] =
2005 omap_vout_alloc_buffer(vout
->buffer_size
,
2006 (u32
*) &vout
->buf_phy_addr
[i
]);
2007 if (!vout
->buf_virt_addr
[i
]) {
2014 vout
->cropped_offset
= 0;
2016 if (ovid
->rotation_type
== VOUT_ROT_VRFB
) {
2017 int static_vrfb_allocation
= (vid_num
== 0) ?
2018 vid1_static_vrfb_alloc
: vid2_static_vrfb_alloc
;
2019 ret
= omap_vout_setup_vrfb_bufs(pdev
, vid_num
,
2020 static_vrfb_allocation
);
2026 for (i
= 0; i
< numbuffers
; i
++) {
2027 omap_vout_free_buffer(vout
->buf_virt_addr
[i
],
2029 vout
->buf_virt_addr
[i
] = 0;
2030 vout
->buf_phy_addr
[i
] = 0;
2036 /* Create video out devices */
2037 static int __init
omap_vout_create_video_devices(struct platform_device
*pdev
)
2040 struct omap_vout_device
*vout
;
2041 struct video_device
*vfd
= NULL
;
2042 struct v4l2_device
*v4l2_dev
= platform_get_drvdata(pdev
);
2043 struct omap2video_device
*vid_dev
= container_of(v4l2_dev
,
2044 struct omap2video_device
, v4l2_dev
);
2046 for (k
= 0; k
< pdev
->num_resources
; k
++) {
2048 vout
= kzalloc(sizeof(struct omap_vout_device
), GFP_KERNEL
);
2050 dev_err(&pdev
->dev
, ": could not allocate memory\n");
2055 vid_dev
->vouts
[k
] = vout
;
2056 vout
->vid_dev
= vid_dev
;
2057 /* Select video2 if only 1 overlay is controlled by V4L2 */
2058 if (pdev
->num_resources
== 1)
2059 vout
->vid_info
.overlays
[0] = vid_dev
->overlays
[k
+ 2];
2061 /* Else select video1 and video2 one by one. */
2062 vout
->vid_info
.overlays
[0] = vid_dev
->overlays
[k
+ 1];
2063 vout
->vid_info
.num_overlays
= 1;
2064 vout
->vid_info
.id
= k
+ 1;
2066 /* Set VRFB as rotation_type for omap2 and omap3 */
2067 if (cpu_is_omap24xx() || cpu_is_omap34xx())
2068 vout
->vid_info
.rotation_type
= VOUT_ROT_VRFB
;
2070 /* Setup the default configuration for the video devices
2072 if (omap_vout_setup_video_data(vout
) != 0) {
2077 /* Allocate default number of buffers for the video streaming
2078 * and reserve the VRFB space for rotation
2080 if (omap_vout_setup_video_bufs(pdev
, k
) != 0) {
2085 /* Register the Video device with V4L2
2088 if (video_register_device(vfd
, VFL_TYPE_GRABBER
, -1) < 0) {
2089 dev_err(&pdev
->dev
, ": Could not register "
2090 "Video for Linux device\n");
2095 video_set_drvdata(vfd
, vout
);
2097 /* Configure the overlay structure */
2098 ret
= omapvid_init(vid_dev
->vouts
[k
], 0);
2103 if (vout
->vid_info
.rotation_type
== VOUT_ROT_VRFB
)
2104 omap_vout_release_vrfb(vout
);
2105 omap_vout_free_buffers(vout
);
2107 video_device_release(vfd
);
2113 dev_info(&pdev
->dev
, ": registered and initialized"
2114 " video device %d\n", vfd
->minor
);
2115 if (k
== (pdev
->num_resources
- 1))
2121 /* Driver functions */
2122 static void omap_vout_cleanup_device(struct omap_vout_device
*vout
)
2124 struct video_device
*vfd
;
2125 struct omapvideo_info
*ovid
;
2131 ovid
= &vout
->vid_info
;
2133 if (!video_is_registered(vfd
)) {
2135 * The device was never registered, so release the
2136 * video_device struct directly.
2138 video_device_release(vfd
);
2141 * The unregister function will release the video_device
2142 * struct as well as unregistering it.
2144 video_unregister_device(vfd
);
2147 if (ovid
->rotation_type
== VOUT_ROT_VRFB
) {
2148 omap_vout_release_vrfb(vout
);
2149 /* Free the VRFB buffer if allocated
2152 if (vout
->vrfb_static_allocation
)
2153 omap_vout_free_vrfb_buffers(vout
);
2155 omap_vout_free_buffers(vout
);
2160 static int omap_vout_remove(struct platform_device
*pdev
)
2163 struct v4l2_device
*v4l2_dev
= platform_get_drvdata(pdev
);
2164 struct omap2video_device
*vid_dev
= container_of(v4l2_dev
, struct
2165 omap2video_device
, v4l2_dev
);
2167 v4l2_device_unregister(v4l2_dev
);
2168 for (k
= 0; k
< pdev
->num_resources
; k
++)
2169 omap_vout_cleanup_device(vid_dev
->vouts
[k
]);
2171 for (k
= 0; k
< vid_dev
->num_displays
; k
++) {
2172 if (vid_dev
->displays
[k
]->state
!= OMAP_DSS_DISPLAY_DISABLED
)
2173 vid_dev
->displays
[k
]->driver
->disable(vid_dev
->displays
[k
]);
2175 omap_dss_put_device(vid_dev
->displays
[k
]);
2181 static int __init
omap_vout_probe(struct platform_device
*pdev
)
2184 struct omap_overlay
*ovl
;
2185 struct omap_dss_device
*dssdev
= NULL
;
2186 struct omap_dss_device
*def_display
;
2187 struct omap2video_device
*vid_dev
= NULL
;
2189 if (pdev
->num_resources
== 0) {
2190 dev_err(&pdev
->dev
, "probed for an unknown device\n");
2194 vid_dev
= kzalloc(sizeof(struct omap2video_device
), GFP_KERNEL
);
2195 if (vid_dev
== NULL
)
2198 vid_dev
->num_displays
= 0;
2199 for_each_dss_dev(dssdev
) {
2200 omap_dss_get_device(dssdev
);
2202 if (!dssdev
->driver
) {
2203 dev_warn(&pdev
->dev
, "no driver for display: %s\n",
2205 omap_dss_put_device(dssdev
);
2209 vid_dev
->displays
[vid_dev
->num_displays
++] = dssdev
;
2212 if (vid_dev
->num_displays
== 0) {
2213 dev_err(&pdev
->dev
, "no displays\n");
2218 vid_dev
->num_overlays
= omap_dss_get_num_overlays();
2219 for (i
= 0; i
< vid_dev
->num_overlays
; i
++)
2220 vid_dev
->overlays
[i
] = omap_dss_get_overlay(i
);
2222 vid_dev
->num_managers
= omap_dss_get_num_overlay_managers();
2223 for (i
= 0; i
< vid_dev
->num_managers
; i
++)
2224 vid_dev
->managers
[i
] = omap_dss_get_overlay_manager(i
);
2226 /* Get the Video1 overlay and video2 overlay.
2227 * Setup the Display attached to that overlays
2229 for (i
= 1; i
< vid_dev
->num_overlays
; i
++) {
2230 ovl
= omap_dss_get_overlay(i
);
2231 dssdev
= ovl
->get_device(ovl
);
2234 def_display
= dssdev
;
2236 dev_warn(&pdev
->dev
, "cannot find display\n");
2240 struct omap_dss_driver
*dssdrv
= def_display
->driver
;
2242 ret
= dssdrv
->enable(def_display
);
2244 /* Here we are not considering a error
2245 * as display may be enabled by frame
2248 dev_warn(&pdev
->dev
,
2249 "'%s' Display already enabled\n",
2255 if (v4l2_device_register(&pdev
->dev
, &vid_dev
->v4l2_dev
) < 0) {
2256 dev_err(&pdev
->dev
, "v4l2_device_register failed\n");
2261 ret
= omap_vout_create_video_devices(pdev
);
2265 for (i
= 0; i
< vid_dev
->num_displays
; i
++) {
2266 struct omap_dss_device
*display
= vid_dev
->displays
[i
];
2268 if (display
->driver
->update
)
2269 display
->driver
->update(display
, 0, 0,
2270 display
->panel
.timings
.x_res
,
2271 display
->panel
.timings
.y_res
);
2276 v4l2_device_unregister(&vid_dev
->v4l2_dev
);
2278 for (i
= 1; i
< vid_dev
->num_overlays
; i
++) {
2280 ovl
= omap_dss_get_overlay(i
);
2281 dssdev
= ovl
->get_device(ovl
);
2284 def_display
= dssdev
;
2286 if (def_display
&& def_display
->driver
)
2287 def_display
->driver
->disable(def_display
);
2294 static struct platform_driver omap_vout_driver
= {
2298 .remove
= omap_vout_remove
,
2301 static int __init
omap_vout_init(void)
2303 if (platform_driver_probe(&omap_vout_driver
, omap_vout_probe
) != 0) {
2304 printk(KERN_ERR VOUT_NAME
":Could not register Video driver\n");
2310 static void omap_vout_cleanup(void)
2312 platform_driver_unregister(&omap_vout_driver
);
2315 late_initcall(omap_vout_init
);
2316 module_exit(omap_vout_cleanup
);