aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/omap
diff options
context:
space:
mode:
authorJonathan Herman <hermanjl@cs.unc.edu>2013-01-22 10:38:37 -0500
committerJonathan Herman <hermanjl@cs.unc.edu>2013-01-22 10:38:37 -0500
commitfcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch)
treea57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/media/video/omap
parent8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff)
Added missing tegra files.HEADmaster
Diffstat (limited to 'drivers/media/video/omap')
-rw-r--r--drivers/media/video/omap/Kconfig14
-rw-r--r--drivers/media/video/omap/Makefile8
-rw-r--r--drivers/media/video/omap/omap_vout.c2261
-rw-r--r--drivers/media/video/omap/omap_vout_vrfb.c390
-rw-r--r--drivers/media/video/omap/omap_vout_vrfb.h40
-rw-r--r--drivers/media/video/omap/omap_voutdef.h225
-rw-r--r--drivers/media/video/omap/omap_voutlib.c339
-rw-r--r--drivers/media/video/omap/omap_voutlib.h36
8 files changed, 3313 insertions, 0 deletions
diff --git a/drivers/media/video/omap/Kconfig b/drivers/media/video/omap/Kconfig
new file mode 100644
index 00000000000..390ab094f9f
--- /dev/null
+++ b/drivers/media/video/omap/Kconfig
@@ -0,0 +1,14 @@
1config VIDEO_OMAP2_VOUT_VRFB
2 bool
3
4config VIDEO_OMAP2_VOUT
5 tristate "OMAP2/OMAP3 V4L2-Display driver"
6 depends on ARCH_OMAP2 || ARCH_OMAP3
7 select VIDEOBUF_GEN
8 select VIDEOBUF_DMA_CONTIG
9 select OMAP2_DSS
10 select OMAP2_VRFB if ARCH_OMAP2 || ARCH_OMAP3
11 select VIDEO_OMAP2_VOUT_VRFB if VIDEO_OMAP2_VOUT && OMAP2_VRFB
12 default n
13 ---help---
14 V4L2 Display driver support for OMAP2/3 based boards.
diff --git a/drivers/media/video/omap/Makefile b/drivers/media/video/omap/Makefile
new file mode 100644
index 00000000000..fc410b438f7
--- /dev/null
+++ b/drivers/media/video/omap/Makefile
@@ -0,0 +1,8 @@
1#
2# Makefile for the omap video device drivers.
3#
4
5# OMAP2/3 Display driver
6omap-vout-y := omap_vout.o omap_voutlib.o
7omap-vout-$(CONFIG_VIDEO_OMAP2_VOUT_VRFB) += omap_vout_vrfb.o
8obj-$(CONFIG_VIDEO_OMAP2_VOUT) += omap-vout.o
diff --git a/drivers/media/video/omap/omap_vout.c b/drivers/media/video/omap/omap_vout.c
new file mode 100644
index 00000000000..3422da0034f
--- /dev/null
+++ b/drivers/media/video/omap/omap_vout.c
@@ -0,0 +1,2261 @@
1/*
2 * omap_vout.c
3 *
4 * Copyright (C) 2005-2010 Texas Instruments.
5 *
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.
9 *
10 * Leveraged code from the OMAP2 camera driver
11 * Video-for-Linux (Version 2) camera capture driver for
12 * the OMAP24xx camera controller.
13 *
14 * Author: Andy Lowe (source@mvista.com)
15 *
16 * Copyright (C) 2004 MontaVista Software, Inc.
17 * Copyright (C) 2010 Texas Instruments.
18 *
19 * History:
20 * 20-APR-2006 Khasim Modified VRFB based Rotation,
21 * The image data is always read from 0 degree
22 * view and written
23 * to the virtual space of desired rotation angle
24 * 4-DEC-2006 Jian Changed to support better memory management
25 *
26 * 17-Nov-2008 Hardik Changed driver to use video_ioctl2
27 *
28 * 23-Feb-2010 Vaibhav H Modified to use new DSS2 interface
29 *
30 */
31
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>
42
43#include <media/videobuf-dma-contig.h>
44#include <media/v4l2-device.h>
45#include <media/v4l2-ioctl.h>
46
47#include <plat/dma.h>
48#include <plat/vrfb.h>
49#include <video/omapdss.h>
50
51#include "omap_voutlib.h"
52#include "omap_voutdef.h"
53#include "omap_vout_vrfb.h"
54
55MODULE_AUTHOR("Texas Instruments");
56MODULE_DESCRIPTION("OMAP Video for Linux Video out driver");
57MODULE_LICENSE("GPL");
58
59/* Driver Configuration macros */
60#define VOUT_NAME "omap_vout"
61
62enum omap_vout_channels {
63 OMAP_VIDEO1,
64 OMAP_VIDEO2,
65};
66
67static struct videobuf_queue_ops video_vbq_ops;
68/* Variables configurable through module params*/
69static u32 video1_numbuffers = 3;
70static u32 video2_numbuffers = 3;
71static u32 video1_bufsize = OMAP_VOUT_MAX_BUF_SIZE;
72static u32 video2_bufsize = OMAP_VOUT_MAX_BUF_SIZE;
73static u32 vid1_static_vrfb_alloc;
74static u32 vid2_static_vrfb_alloc;
75static int debug;
76
77/* Module parameters */
78module_param(video1_numbuffers, uint, S_IRUGO);
79MODULE_PARM_DESC(video1_numbuffers,
80 "Number of buffers to be allocated at init time for Video1 device.");
81
82module_param(video2_numbuffers, uint, S_IRUGO);
83MODULE_PARM_DESC(video2_numbuffers,
84 "Number of buffers to be allocated at init time for Video2 device.");
85
86module_param(video1_bufsize, uint, S_IRUGO);
87MODULE_PARM_DESC(video1_bufsize,
88 "Size of the buffer to be allocated for video1 device");
89
90module_param(video2_bufsize, uint, S_IRUGO);
91MODULE_PARM_DESC(video2_bufsize,
92 "Size of the buffer to be allocated for video2 device");
93
94module_param(vid1_static_vrfb_alloc, bool, S_IRUGO);
95MODULE_PARM_DESC(vid1_static_vrfb_alloc,
96 "Static allocation of the VRFB buffer for video1 device");
97
98module_param(vid2_static_vrfb_alloc, bool, S_IRUGO);
99MODULE_PARM_DESC(vid2_static_vrfb_alloc,
100 "Static allocation of the VRFB buffer for video2 device");
101
102module_param(debug, bool, S_IRUGO);
103MODULE_PARM_DESC(debug, "Debug level (0-1)");
104
105/* list of image formats supported by OMAP2 video pipelines */
106static const struct v4l2_fmtdesc omap_formats[] = {
107 {
108 /* Note: V4L2 defines RGB565 as:
109 *
110 * Byte 0 Byte 1
111 * g2 g1 g0 r4 r3 r2 r1 r0 b4 b3 b2 b1 b0 g5 g4 g3
112 *
113 * We interpret RGB565 as:
114 *
115 * Byte 0 Byte 1
116 * g2 g1 g0 b4 b3 b2 b1 b0 r4 r3 r2 r1 r0 g5 g4 g3
117 */
118 .description = "RGB565, le",
119 .pixelformat = V4L2_PIX_FMT_RGB565,
120 },
121 {
122 /* Note: V4L2 defines RGB32 as: RGB-8-8-8-8 we use
123 * this for RGB24 unpack mode, the last 8 bits are ignored
124 * */
125 .description = "RGB32, le",
126 .pixelformat = V4L2_PIX_FMT_RGB32,
127 },
128 {
129 /* Note: V4L2 defines RGB24 as: RGB-8-8-8 we use
130 * this for RGB24 packed mode
131 *
132 */
133 .description = "RGB24, le",
134 .pixelformat = V4L2_PIX_FMT_RGB24,
135 },
136 {
137 .description = "YUYV (YUV 4:2:2), packed",
138 .pixelformat = V4L2_PIX_FMT_YUYV,
139 },
140 {
141 .description = "UYVY, packed",
142 .pixelformat = V4L2_PIX_FMT_UYVY,
143 },
144};
145
146#define NUM_OUTPUT_FORMATS (ARRAY_SIZE(omap_formats))
147
148/*
149 * Try format
150 */
151static int omap_vout_try_format(struct v4l2_pix_format *pix)
152{
153 int ifmt, bpp = 0;
154
155 pix->height = clamp(pix->height, (u32)VID_MIN_HEIGHT,
156 (u32)VID_MAX_HEIGHT);
157 pix->width = clamp(pix->width, (u32)VID_MIN_WIDTH, (u32)VID_MAX_WIDTH);
158
159 for (ifmt = 0; ifmt < NUM_OUTPUT_FORMATS; ifmt++) {
160 if (pix->pixelformat == omap_formats[ifmt].pixelformat)
161 break;
162 }
163
164 if (ifmt == NUM_OUTPUT_FORMATS)
165 ifmt = 0;
166
167 pix->pixelformat = omap_formats[ifmt].pixelformat;
168 pix->field = V4L2_FIELD_ANY;
169 pix->priv = 0;
170
171 switch (pix->pixelformat) {
172 case V4L2_PIX_FMT_YUYV:
173 case V4L2_PIX_FMT_UYVY:
174 default:
175 pix->colorspace = V4L2_COLORSPACE_JPEG;
176 bpp = YUYV_BPP;
177 break;
178 case V4L2_PIX_FMT_RGB565:
179 case V4L2_PIX_FMT_RGB565X:
180 pix->colorspace = V4L2_COLORSPACE_SRGB;
181 bpp = RGB565_BPP;
182 break;
183 case V4L2_PIX_FMT_RGB24:
184 pix->colorspace = V4L2_COLORSPACE_SRGB;
185 bpp = RGB24_BPP;
186 break;
187 case V4L2_PIX_FMT_RGB32:
188 case V4L2_PIX_FMT_BGR32:
189 pix->colorspace = V4L2_COLORSPACE_SRGB;
190 bpp = RGB32_BPP;
191 break;
192 }
193 pix->bytesperline = pix->width * bpp;
194 pix->sizeimage = pix->bytesperline * pix->height;
195
196 return bpp;
197}
198
199/*
200 * omap_vout_uservirt_to_phys: This inline function is used to convert user
201 * space virtual address to physical address.
202 */
203static u32 omap_vout_uservirt_to_phys(u32 virtp)
204{
205 unsigned long physp = 0;
206 struct vm_area_struct *vma;
207 struct mm_struct *mm = current->mm;
208
209 vma = find_vma(mm, virtp);
210 /* For kernel direct-mapped memory, take the easy way */
211 if (virtp >= PAGE_OFFSET) {
212 physp = virt_to_phys((void *) virtp);
213 } else if (vma && (vma->vm_flags & VM_IO) && vma->vm_pgoff) {
214 /* this will catch, kernel-allocated, mmaped-to-usermode
215 addresses */
216 physp = (vma->vm_pgoff << PAGE_SHIFT) + (virtp - vma->vm_start);
217 } else {
218 /* otherwise, use get_user_pages() for general userland pages */
219 int res, nr_pages = 1;
220 struct page *pages;
221 down_read(&current->mm->mmap_sem);
222
223 res = get_user_pages(current, current->mm, virtp, nr_pages, 1,
224 0, &pages, NULL);
225 up_read(&current->mm->mmap_sem);
226
227 if (res == nr_pages) {
228 physp = __pa(page_address(&pages[0]) +
229 (virtp & ~PAGE_MASK));
230 } else {
231 printk(KERN_WARNING VOUT_NAME
232 "get_user_pages failed\n");
233 return 0;
234 }
235 }
236
237 return physp;
238}
239
240/*
241 * Free the V4L2 buffers
242 */
243void omap_vout_free_buffers(struct omap_vout_device *vout)
244{
245 int i, numbuffers;
246
247 /* Allocate memory for the buffers */
248 numbuffers = (vout->vid) ? video2_numbuffers : video1_numbuffers;
249 vout->buffer_size = (vout->vid) ? video2_bufsize : video1_bufsize;
250
251 for (i = 0; i < numbuffers; i++) {
252 omap_vout_free_buffer(vout->buf_virt_addr[i],
253 vout->buffer_size);
254 vout->buf_phy_addr[i] = 0;
255 vout->buf_virt_addr[i] = 0;
256 }
257}
258
259/*
260 * Convert V4L2 rotation to DSS rotation
261 * V4L2 understand 0, 90, 180, 270.
262 * Convert to 0, 1, 2 and 3 respectively for DSS
263 */
264static int v4l2_rot_to_dss_rot(int v4l2_rotation,
265 enum dss_rotation *rotation, bool mirror)
266{
267 int ret = 0;
268
269 switch (v4l2_rotation) {
270 case 90:
271 *rotation = dss_rotation_90_degree;
272 break;
273 case 180:
274 *rotation = dss_rotation_180_degree;
275 break;
276 case 270:
277 *rotation = dss_rotation_270_degree;
278 break;
279 case 0:
280 *rotation = dss_rotation_0_degree;
281 break;
282 default:
283 ret = -EINVAL;
284 }
285 return ret;
286}
287
288static int omap_vout_calculate_offset(struct omap_vout_device *vout)
289{
290 struct omapvideo_info *ovid;
291 struct v4l2_rect *crop = &vout->crop;
292 struct v4l2_pix_format *pix = &vout->pix;
293 int *cropped_offset = &vout->cropped_offset;
294 int ps = 2, line_length = 0;
295
296 ovid = &vout->vid_info;
297
298 if (ovid->rotation_type == VOUT_ROT_VRFB) {
299 omap_vout_calculate_vrfb_offset(vout);
300 } else {
301 vout->line_length = line_length = pix->width;
302
303 if (V4L2_PIX_FMT_YUYV == pix->pixelformat ||
304 V4L2_PIX_FMT_UYVY == pix->pixelformat)
305 ps = 2;
306 else if (V4L2_PIX_FMT_RGB32 == pix->pixelformat)
307 ps = 4;
308 else if (V4L2_PIX_FMT_RGB24 == pix->pixelformat)
309 ps = 3;
310
311 vout->ps = ps;
312
313 *cropped_offset = (line_length * ps) *
314 crop->top + crop->left * ps;
315 }
316
317 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "%s Offset:%x\n",
318 __func__, vout->cropped_offset);
319
320 return 0;
321}
322
323/*
324 * Convert V4L2 pixel format to DSS pixel format
325 */
326static int video_mode_to_dss_mode(struct omap_vout_device *vout)
327{
328 struct omap_overlay *ovl;
329 struct omapvideo_info *ovid;
330 struct v4l2_pix_format *pix = &vout->pix;
331 enum omap_color_mode mode;
332
333 ovid = &vout->vid_info;
334 ovl = ovid->overlays[0];
335
336 switch (pix->pixelformat) {
337 case 0:
338 break;
339 case V4L2_PIX_FMT_YUYV:
340 mode = OMAP_DSS_COLOR_YUV2;
341 break;
342 case V4L2_PIX_FMT_UYVY:
343 mode = OMAP_DSS_COLOR_UYVY;
344 break;
345 case V4L2_PIX_FMT_RGB565:
346 mode = OMAP_DSS_COLOR_RGB16;
347 break;
348 case V4L2_PIX_FMT_RGB24:
349 mode = OMAP_DSS_COLOR_RGB24P;
350 break;
351 case V4L2_PIX_FMT_RGB32:
352 mode = (ovl->id == OMAP_DSS_VIDEO1) ?
353 OMAP_DSS_COLOR_RGB24U : OMAP_DSS_COLOR_ARGB32;
354 break;
355 case V4L2_PIX_FMT_BGR32:
356 mode = OMAP_DSS_COLOR_RGBX32;
357 break;
358 default:
359 mode = -EINVAL;
360 }
361 return mode;
362}
363
364/*
365 * Setup the overlay
366 */
367static int omapvid_setup_overlay(struct omap_vout_device *vout,
368 struct omap_overlay *ovl, int posx, int posy, int outw,
369 int outh, u32 addr)
370{
371 int ret = 0;
372 struct omap_overlay_info info;
373 int cropheight, cropwidth, pixheight, pixwidth;
374
375 if ((ovl->caps & OMAP_DSS_OVL_CAP_SCALE) == 0 &&
376 (outw != vout->pix.width || outh != vout->pix.height)) {
377 ret = -EINVAL;
378 goto setup_ovl_err;
379 }
380
381 vout->dss_mode = video_mode_to_dss_mode(vout);
382 if (vout->dss_mode == -EINVAL) {
383 ret = -EINVAL;
384 goto setup_ovl_err;
385 }
386
387 /* Setup the input plane parameters according to
388 * rotation value selected.
389 */
390 if (is_rotation_90_or_270(vout)) {
391 cropheight = vout->crop.width;
392 cropwidth = vout->crop.height;
393 pixheight = vout->pix.width;
394 pixwidth = vout->pix.height;
395 } else {
396 cropheight = vout->crop.height;
397 cropwidth = vout->crop.width;
398 pixheight = vout->pix.height;
399 pixwidth = vout->pix.width;
400 }
401
402 ovl->get_overlay_info(ovl, &info);
403 info.paddr = addr;
404 info.vaddr = NULL;
405 info.width = cropwidth;
406 info.height = cropheight;
407 info.color_mode = vout->dss_mode;
408 info.mirror = vout->mirror;
409 info.pos_x = posx;
410 info.pos_y = posy;
411 info.out_width = outw;
412 info.out_height = outh;
413 info.global_alpha = vout->win.global_alpha;
414 if (!is_rotation_enabled(vout)) {
415 info.rotation = 0;
416 info.rotation_type = OMAP_DSS_ROT_DMA;
417 info.screen_width = pixwidth;
418 } else {
419 info.rotation = vout->rotation;
420 info.rotation_type = OMAP_DSS_ROT_VRFB;
421 info.screen_width = 2048;
422 }
423
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__, info.enabled, 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,
431 info.screen_width);
432
433 ret = ovl->set_overlay_info(ovl, &info);
434 if (ret)
435 goto setup_ovl_err;
436
437 return 0;
438
439setup_ovl_err:
440 v4l2_warn(&vout->vid_dev->v4l2_dev, "setup_overlay failed\n");
441 return ret;
442}
443
444/*
445 * Initialize the overlay structure
446 */
447static int omapvid_init(struct omap_vout_device *vout, u32 addr)
448{
449 int ret = 0, i;
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;
455
456 win = &vout->win;
457 for (i = 0; i < ovid->num_overlays; i++) {
458 ovl = ovid->overlays[i];
459 if (!ovl->manager || !ovl->manager->device)
460 return -EINVAL;
461
462 timing = &ovl->manager->device->panel.timings;
463
464 outw = win->w.width;
465 outh = win->w.height;
466 switch (vout->rotation) {
467 case dss_rotation_90_degree:
468 /* Invert the height and width for 90
469 * and 270 degree rotation
470 */
471 temp = outw;
472 outw = outh;
473 outh = temp;
474 posy = (timing->y_res - win->w.width) - win->w.left;
475 posx = win->w.top;
476 break;
477
478 case dss_rotation_180_degree:
479 posx = (timing->x_res - win->w.width) - win->w.left;
480 posy = (timing->y_res - win->w.height) - win->w.top;
481 break;
482
483 case dss_rotation_270_degree:
484 temp = outw;
485 outw = outh;
486 outh = temp;
487 posy = win->w.left;
488 posx = (timing->x_res - win->w.height) - win->w.top;
489 break;
490
491 default:
492 posx = win->w.left;
493 posy = win->w.top;
494 break;
495 }
496
497 ret = omapvid_setup_overlay(vout, ovl, posx, posy,
498 outw, outh, addr);
499 if (ret)
500 goto omapvid_init_err;
501 }
502 return 0;
503
504omapvid_init_err:
505 v4l2_warn(&vout->vid_dev->v4l2_dev, "apply_changes failed\n");
506 return ret;
507}
508
509/*
510 * Apply the changes set the go bit of DSS
511 */
512static int omapvid_apply_changes(struct omap_vout_device *vout)
513{
514 int i;
515 struct omap_overlay *ovl;
516 struct omapvideo_info *ovid = &vout->vid_info;
517
518 for (i = 0; i < ovid->num_overlays; i++) {
519 ovl = ovid->overlays[i];
520 if (!ovl->manager || !ovl->manager->device)
521 return -EINVAL;
522 ovl->manager->apply(ovl->manager);
523 }
524
525 return 0;
526}
527
528static void omap_vout_isr(void *arg, unsigned int irqstatus)
529{
530 int ret;
531 u32 addr, fid;
532 struct omap_overlay *ovl;
533 struct timeval timevalue;
534 struct omapvideo_info *ovid;
535 struct omap_dss_device *cur_display;
536 struct omap_vout_device *vout = (struct omap_vout_device *)arg;
537
538 if (!vout->streaming)
539 return;
540
541 ovid = &vout->vid_info;
542 ovl = ovid->overlays[0];
543 /* get the display device attached to the overlay */
544 if (!ovl->manager || !ovl->manager->device)
545 return;
546
547 cur_display = ovl->manager->device;
548
549 spin_lock(&vout->vbq_lock);
550 do_gettimeofday(&timevalue);
551
552 if (cur_display->type != OMAP_DISPLAY_TYPE_VENC) {
553 switch (cur_display->type) {
554 case OMAP_DISPLAY_TYPE_DPI:
555 if (!(irqstatus & (DISPC_IRQ_VSYNC | DISPC_IRQ_VSYNC2)))
556 goto vout_isr_err;
557 break;
558 case OMAP_DISPLAY_TYPE_HDMI:
559 if (!(irqstatus & DISPC_IRQ_EVSYNC_EVEN))
560 goto vout_isr_err;
561 break;
562 default:
563 goto vout_isr_err;
564 }
565 if (!vout->first_int && (vout->cur_frm != vout->next_frm)) {
566 vout->cur_frm->ts = timevalue;
567 vout->cur_frm->state = VIDEOBUF_DONE;
568 wake_up_interruptible(&vout->cur_frm->done);
569 vout->cur_frm = vout->next_frm;
570 }
571 vout->first_int = 0;
572 if (list_empty(&vout->dma_queue))
573 goto vout_isr_err;
574
575 vout->next_frm = list_entry(vout->dma_queue.next,
576 struct videobuf_buffer, queue);
577 list_del(&vout->next_frm->queue);
578
579 vout->next_frm->state = VIDEOBUF_ACTIVE;
580
581 addr = (unsigned long) vout->queued_buf_addr[vout->next_frm->i]
582 + vout->cropped_offset;
583
584 /* First save the configuration in ovelray structure */
585 ret = omapvid_init(vout, addr);
586 if (ret)
587 printk(KERN_ERR VOUT_NAME
588 "failed to set overlay info\n");
589 /* Enable the pipeline and set the Go bit */
590 ret = omapvid_apply_changes(vout);
591 if (ret)
592 printk(KERN_ERR VOUT_NAME "failed to change mode\n");
593 } else {
594
595 if (vout->first_int) {
596 vout->first_int = 0;
597 goto vout_isr_err;
598 }
599 if (irqstatus & DISPC_IRQ_EVSYNC_ODD)
600 fid = 1;
601 else if (irqstatus & DISPC_IRQ_EVSYNC_EVEN)
602 fid = 0;
603 else
604 goto vout_isr_err;
605
606 vout->field_id ^= 1;
607 if (fid != vout->field_id) {
608 if (0 == fid)
609 vout->field_id = fid;
610
611 goto vout_isr_err;
612 }
613 if (0 == fid) {
614 if (vout->cur_frm == vout->next_frm)
615 goto vout_isr_err;
616
617 vout->cur_frm->ts = timevalue;
618 vout->cur_frm->state = VIDEOBUF_DONE;
619 wake_up_interruptible(&vout->cur_frm->done);
620 vout->cur_frm = vout->next_frm;
621 } else if (1 == fid) {
622 if (list_empty(&vout->dma_queue) ||
623 (vout->cur_frm != vout->next_frm))
624 goto vout_isr_err;
625
626 vout->next_frm = list_entry(vout->dma_queue.next,
627 struct videobuf_buffer, queue);
628 list_del(&vout->next_frm->queue);
629
630 vout->next_frm->state = VIDEOBUF_ACTIVE;
631 addr = (unsigned long)
632 vout->queued_buf_addr[vout->next_frm->i] +
633 vout->cropped_offset;
634 /* First save the configuration in ovelray structure */
635 ret = omapvid_init(vout, addr);
636 if (ret)
637 printk(KERN_ERR VOUT_NAME
638 "failed to set overlay info\n");
639 /* Enable the pipeline and set the Go bit */
640 ret = omapvid_apply_changes(vout);
641 if (ret)
642 printk(KERN_ERR VOUT_NAME
643 "failed to change mode\n");
644 }
645
646 }
647
648vout_isr_err:
649 spin_unlock(&vout->vbq_lock);
650}
651
652
653/* Video buffer call backs */
654
655/*
656 * Buffer setup function is called by videobuf layer when REQBUF ioctl is
657 * called. This is used to setup buffers and return size and count of
658 * buffers allocated. After the call to this buffer, videobuf layer will
659 * setup buffer queue depending on the size and count of buffers
660 */
661static int omap_vout_buffer_setup(struct videobuf_queue *q, unsigned int *count,
662 unsigned int *size)
663{
664 int startindex = 0, i, j;
665 u32 phy_addr = 0, virt_addr = 0;
666 struct omap_vout_device *vout = q->priv_data;
667 struct omapvideo_info *ovid = &vout->vid_info;
668
669 if (!vout)
670 return -EINVAL;
671
672 if (V4L2_BUF_TYPE_VIDEO_OUTPUT != q->type)
673 return -EINVAL;
674
675 startindex = (vout->vid == OMAP_VIDEO1) ?
676 video1_numbuffers : video2_numbuffers;
677 if (V4L2_MEMORY_MMAP == vout->memory && *count < startindex)
678 *count = startindex;
679
680 if (ovid->rotation_type == VOUT_ROT_VRFB) {
681 if (omap_vout_vrfb_buffer_setup(vout, count, startindex))
682 return -ENOMEM;
683 }
684
685 if (V4L2_MEMORY_MMAP != vout->memory)
686 return 0;
687
688 /* Now allocated the V4L2 buffers */
689 *size = PAGE_ALIGN(vout->pix.width * vout->pix.height * vout->bpp);
690 startindex = (vout->vid == OMAP_VIDEO1) ?
691 video1_numbuffers : video2_numbuffers;
692
693 /* Check the size of the buffer */
694 if (*size > vout->buffer_size) {
695 v4l2_err(&vout->vid_dev->v4l2_dev,
696 "buffer allocation mismatch [%u] [%u]\n",
697 *size, vout->buffer_size);
698 return -ENOMEM;
699 }
700
701 for (i = startindex; i < *count; i++) {
702 vout->buffer_size = *size;
703
704 virt_addr = omap_vout_alloc_buffer(vout->buffer_size,
705 &phy_addr);
706 if (!virt_addr) {
707 if (ovid->rotation_type == VOUT_ROT_NONE) {
708 break;
709 } else {
710 if (!is_rotation_enabled(vout))
711 break;
712 /* Free the VRFB buffers if no space for V4L2 buffers */
713 for (j = i; j < *count; j++) {
714 omap_vout_free_buffer(
715 vout->smsshado_virt_addr[j],
716 vout->smsshado_size);
717 vout->smsshado_virt_addr[j] = 0;
718 vout->smsshado_phy_addr[j] = 0;
719 }
720 }
721 }
722 vout->buf_virt_addr[i] = virt_addr;
723 vout->buf_phy_addr[i] = phy_addr;
724 }
725 *count = vout->buffer_allocated = i;
726
727 return 0;
728}
729
730/*
731 * Free the V4L2 buffers additionally allocated than default
732 * number of buffers
733 */
734static void omap_vout_free_extra_buffers(struct omap_vout_device *vout)
735{
736 int num_buffers = 0, i;
737
738 num_buffers = (vout->vid == OMAP_VIDEO1) ?
739 video1_numbuffers : video2_numbuffers;
740
741 for (i = num_buffers; i < vout->buffer_allocated; i++) {
742 if (vout->buf_virt_addr[i])
743 omap_vout_free_buffer(vout->buf_virt_addr[i],
744 vout->buffer_size);
745
746 vout->buf_virt_addr[i] = 0;
747 vout->buf_phy_addr[i] = 0;
748 }
749 vout->buffer_allocated = num_buffers;
750}
751
752/*
753 * This function will be called when VIDIOC_QBUF ioctl is called.
754 * It prepare buffers before give out for the display. This function
755 * converts user space virtual address into physical address if userptr memory
756 * exchange mechanism is used. If rotation is enabled, it copies entire
757 * buffer into VRFB memory space before giving it to the DSS.
758 */
759static int omap_vout_buffer_prepare(struct videobuf_queue *q,
760 struct videobuf_buffer *vb,
761 enum v4l2_field field)
762{
763 struct omap_vout_device *vout = q->priv_data;
764 struct omapvideo_info *ovid = &vout->vid_info;
765
766 if (VIDEOBUF_NEEDS_INIT == vb->state) {
767 vb->width = vout->pix.width;
768 vb->height = vout->pix.height;
769 vb->size = vb->width * vb->height * vout->bpp;
770 vb->field = field;
771 }
772 vb->state = VIDEOBUF_PREPARED;
773 /* if user pointer memory mechanism is used, get the physical
774 * address of the buffer
775 */
776 if (V4L2_MEMORY_USERPTR == vb->memory) {
777 if (0 == vb->baddr)
778 return -EINVAL;
779 /* Physical address */
780 vout->queued_buf_addr[vb->i] = (u8 *)
781 omap_vout_uservirt_to_phys(vb->baddr);
782 } else {
783 u32 addr, dma_addr;
784 unsigned long size;
785
786 addr = (unsigned long) vout->buf_virt_addr[vb->i];
787 size = (unsigned long) vb->size;
788
789 dma_addr = dma_map_single(vout->vid_dev->v4l2_dev.dev, (void *) addr,
790 size, DMA_TO_DEVICE);
791 if (dma_mapping_error(vout->vid_dev->v4l2_dev.dev, dma_addr))
792 v4l2_err(&vout->vid_dev->v4l2_dev, "dma_map_single failed\n");
793
794 vout->queued_buf_addr[vb->i] = (u8 *)vout->buf_phy_addr[vb->i];
795 }
796
797 if (ovid->rotation_type == VOUT_ROT_VRFB)
798 return omap_vout_prepare_vrfb(vout, vb);
799 else
800 return 0;
801}
802
803/*
804 * Buffer queue function will be called from the videobuf layer when _QBUF
805 * ioctl is called. It is used to enqueue buffer, which is ready to be
806 * displayed.
807 */
808static void omap_vout_buffer_queue(struct videobuf_queue *q,
809 struct videobuf_buffer *vb)
810{
811 struct omap_vout_device *vout = q->priv_data;
812
813 /* Driver is also maintainig a queue. So enqueue buffer in the driver
814 * queue */
815 list_add_tail(&vb->queue, &vout->dma_queue);
816
817 vb->state = VIDEOBUF_QUEUED;
818}
819
820/*
821 * Buffer release function is called from videobuf layer to release buffer
822 * which are already allocated
823 */
824static void omap_vout_buffer_release(struct videobuf_queue *q,
825 struct videobuf_buffer *vb)
826{
827 struct omap_vout_device *vout = q->priv_data;
828
829 vb->state = VIDEOBUF_NEEDS_INIT;
830
831 if (V4L2_MEMORY_MMAP != vout->memory)
832 return;
833}
834
835/*
836 * File operations
837 */
838static void omap_vout_vm_open(struct vm_area_struct *vma)
839{
840 struct omap_vout_device *vout = vma->vm_private_data;
841
842 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev,
843 "vm_open [vma=%08lx-%08lx]\n", vma->vm_start, vma->vm_end);
844 vout->mmap_count++;
845}
846
847static void omap_vout_vm_close(struct vm_area_struct *vma)
848{
849 struct omap_vout_device *vout = vma->vm_private_data;
850
851 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev,
852 "vm_close [vma=%08lx-%08lx]\n", vma->vm_start, vma->vm_end);
853 vout->mmap_count--;
854}
855
856static struct vm_operations_struct omap_vout_vm_ops = {
857 .open = omap_vout_vm_open,
858 .close = omap_vout_vm_close,
859};
860
861static int omap_vout_mmap(struct file *file, struct vm_area_struct *vma)
862{
863 int i;
864 void *pos;
865 unsigned long start = vma->vm_start;
866 unsigned long size = (vma->vm_end - vma->vm_start);
867 struct omap_vout_device *vout = file->private_data;
868 struct videobuf_queue *q = &vout->vbq;
869
870 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev,
871 " %s pgoff=0x%lx, start=0x%lx, end=0x%lx\n", __func__,
872 vma->vm_pgoff, vma->vm_start, vma->vm_end);
873
874 /* look for the buffer to map */
875 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
876 if (NULL == q->bufs[i])
877 continue;
878 if (V4L2_MEMORY_MMAP != q->bufs[i]->memory)
879 continue;
880 if (q->bufs[i]->boff == (vma->vm_pgoff << PAGE_SHIFT))
881 break;
882 }
883
884 if (VIDEO_MAX_FRAME == i) {
885 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev,
886 "offset invalid [offset=0x%lx]\n",
887 (vma->vm_pgoff << PAGE_SHIFT));
888 return -EINVAL;
889 }
890 /* Check the size of the buffer */
891 if (size > vout->buffer_size) {
892 v4l2_err(&vout->vid_dev->v4l2_dev,
893 "insufficient memory [%lu] [%u]\n",
894 size, vout->buffer_size);
895 return -ENOMEM;
896 }
897
898 q->bufs[i]->baddr = vma->vm_start;
899
900 vma->vm_flags |= VM_RESERVED;
901 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
902 vma->vm_ops = &omap_vout_vm_ops;
903 vma->vm_private_data = (void *) vout;
904 pos = (void *)vout->buf_virt_addr[i];
905 vma->vm_pgoff = virt_to_phys((void *)pos) >> PAGE_SHIFT;
906 while (size > 0) {
907 unsigned long pfn;
908 pfn = virt_to_phys((void *) pos) >> PAGE_SHIFT;
909 if (remap_pfn_range(vma, start, pfn, PAGE_SIZE, PAGE_SHARED))
910 return -EAGAIN;
911 start += PAGE_SIZE;
912 pos += PAGE_SIZE;
913 size -= PAGE_SIZE;
914 }
915 vout->mmap_count++;
916 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "Exiting %s\n", __func__);
917
918 return 0;
919}
920
921static int omap_vout_release(struct file *file)
922{
923 unsigned int ret, i;
924 struct videobuf_queue *q;
925 struct omapvideo_info *ovid;
926 struct omap_vout_device *vout = file->private_data;
927
928 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "Entering %s\n", __func__);
929 ovid = &vout->vid_info;
930
931 if (!vout)
932 return 0;
933
934 q = &vout->vbq;
935 /* Disable all the overlay managers connected with this interface */
936 for (i = 0; i < ovid->num_overlays; i++) {
937 struct omap_overlay *ovl = ovid->overlays[i];
938 if (ovl->manager && ovl->manager->device) {
939 struct omap_overlay_info info;
940 ovl->get_overlay_info(ovl, &info);
941 info.enabled = 0;
942 ovl->set_overlay_info(ovl, &info);
943 }
944 }
945 /* Turn off the pipeline */
946 ret = omapvid_apply_changes(vout);
947 if (ret)
948 v4l2_warn(&vout->vid_dev->v4l2_dev,
949 "Unable to apply changes\n");
950
951 /* Free all buffers */
952 omap_vout_free_extra_buffers(vout);
953
954 /* Free the VRFB buffers only if they are allocated
955 * during reqbufs. Don't free if init time allocated
956 */
957 if (ovid->rotation_type == VOUT_ROT_VRFB) {
958 if (!vout->vrfb_static_allocation)
959 omap_vout_free_vrfb_buffers(vout);
960 }
961 videobuf_mmap_free(q);
962
963 /* Even if apply changes fails we should continue
964 freeing allocated memory */
965 if (vout->streaming) {
966 u32 mask = 0;
967
968 mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_EVEN |
969 DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_VSYNC2;
970 omap_dispc_unregister_isr(omap_vout_isr, vout, mask);
971 vout->streaming = 0;
972
973 videobuf_streamoff(q);
974 videobuf_queue_cancel(q);
975 }
976
977 if (vout->mmap_count != 0)
978 vout->mmap_count = 0;
979
980 vout->opened -= 1;
981 file->private_data = NULL;
982
983 if (vout->buffer_allocated)
984 videobuf_mmap_free(q);
985
986 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "Exiting %s\n", __func__);
987 return ret;
988}
989
990static int omap_vout_open(struct file *file)
991{
992 struct videobuf_queue *q;
993 struct omap_vout_device *vout = NULL;
994
995 vout = video_drvdata(file);
996 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "Entering %s\n", __func__);
997
998 if (vout == NULL)
999 return -ENODEV;
1000
1001 /* for now, we only support single open */
1002 if (vout->opened)
1003 return -EBUSY;
1004
1005 vout->opened += 1;
1006
1007 file->private_data = vout;
1008 vout->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1009
1010 q = &vout->vbq;
1011 video_vbq_ops.buf_setup = omap_vout_buffer_setup;
1012 video_vbq_ops.buf_prepare = omap_vout_buffer_prepare;
1013 video_vbq_ops.buf_release = omap_vout_buffer_release;
1014 video_vbq_ops.buf_queue = omap_vout_buffer_queue;
1015 spin_lock_init(&vout->vbq_lock);
1016
1017 videobuf_queue_dma_contig_init(q, &video_vbq_ops, q->dev,
1018 &vout->vbq_lock, vout->type, V4L2_FIELD_NONE,
1019 sizeof(struct videobuf_buffer), vout, NULL);
1020
1021 v4l2_dbg(1, debug, &vout->vid_dev->v4l2_dev, "Exiting %s\n", __func__);
1022 return 0;
1023}
1024
1025/*
1026 * V4L2 ioctls
1027 */
1028static int vidioc_querycap(struct file *file, void *fh,
1029 struct v4l2_capability *cap)
1030{
1031 struct omap_vout_device *vout = fh;
1032
1033 strlcpy(cap->driver, VOUT_NAME, sizeof(cap->driver));
1034 strlcpy(cap->card, vout->vfd->name, sizeof(cap->card));
1035 cap->bus_info[0] = '\0';
1036 cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT;
1037
1038 return 0;
1039}
1040
1041static int vidioc_enum_fmt_vid_out(struct file *file, void *fh,
1042 struct v4l2_fmtdesc *fmt)
1043{
1044 int index = fmt->index;
1045
1046 if (index >= NUM_OUTPUT_FORMATS)
1047 return -EINVAL;
1048
1049 fmt->flags = omap_formats[index].flags;
1050 strlcpy(fmt->description, omap_formats[index].description,
1051 sizeof(fmt->description));
1052 fmt->pixelformat = omap_formats[index].pixelformat;
1053
1054 return 0;
1055}
1056
1057static int vidioc_g_fmt_vid_out(struct file *file, void *fh,
1058 struct v4l2_format *f)
1059{
1060 struct omap_vout_device *vout = fh;
1061
1062 f->fmt.pix = vout->pix;
1063 return 0;
1064
1065}
1066
1067static int vidioc_try_fmt_vid_out(struct file *file, void *fh,
1068 struct v4l2_format *f)
1069{
1070 struct omap_overlay *ovl;
1071 struct omapvideo_info *ovid;
1072 struct omap_video_timings *timing;
1073 struct omap_vout_device *vout = fh;
1074
1075 ovid = &vout->vid_info;
1076 ovl = ovid->overlays[0];
1077
1078 if (!ovl->manager || !ovl->manager->device)
1079 return -EINVAL;
1080 /* get the display device attached to the overlay */
1081 timing = &ovl->manager->device->panel.timings;
1082
1083 vout->fbuf.fmt.height = timing->y_res;
1084 vout->fbuf.fmt.width = timing->x_res;
1085
1086 omap_vout_try_format(&f->fmt.pix);
1087 return 0;
1088}
1089
1090static int vidioc_s_fmt_vid_out(struct file *file, void *fh,
1091 struct v4l2_format *f)
1092{
1093 int ret, bpp;
1094 struct omap_overlay *ovl;
1095 struct omapvideo_info *ovid;
1096 struct omap_video_timings *timing;
1097 struct omap_vout_device *vout = fh;
1098
1099 if (vout->streaming)
1100 return -EBUSY;
1101
1102 mutex_lock(&vout->lock);
1103
1104 ovid = &vout->vid_info;
1105 ovl = ovid->overlays[0];
1106
1107 /* get the display device attached to the overlay */
1108 if (!ovl->manager || !ovl->manager->device) {
1109 ret = -EINVAL;
1110 goto s_fmt_vid_out_exit;
1111 }
1112 timing = &ovl->manager->device->panel.timings;
1113
1114 /* We dont support RGB24-packed mode if vrfb rotation
1115 * is enabled*/
1116 if ((is_rotation_enabled(vout)) &&
1117 f->fmt.pix.pixelformat == V4L2_PIX_FMT_RGB24) {
1118 ret = -EINVAL;
1119 goto s_fmt_vid_out_exit;
1120 }
1121
1122 /* get the framebuffer parameters */
1123
1124 if (is_rotation_90_or_270(vout)) {
1125 vout->fbuf.fmt.height = timing->x_res;
1126 vout->fbuf.fmt.width = timing->y_res;
1127 } else {
1128 vout->fbuf.fmt.height = timing->y_res;
1129 vout->fbuf.fmt.width = timing->x_res;
1130 }
1131
1132 /* change to samller size is OK */
1133
1134 bpp = omap_vout_try_format(&f->fmt.pix);
1135 f->fmt.pix.sizeimage = f->fmt.pix.width * f->fmt.pix.height * bpp;
1136
1137 /* try & set the new output format */
1138 vout->bpp = bpp;
1139 vout->pix = f->fmt.pix;
1140 vout->vrfb_bpp = 1;
1141
1142 /* If YUYV then vrfb bpp is 2, for others its 1 */
1143 if (V4L2_PIX_FMT_YUYV == vout->pix.pixelformat ||
1144 V4L2_PIX_FMT_UYVY == vout->pix.pixelformat)
1145 vout->vrfb_bpp = 2;
1146
1147 /* set default crop and win */
1148 omap_vout_new_format(&vout->pix, &vout->fbuf, &vout->crop, &vout->win);
1149
1150 /* Save the changes in the overlay strcuture */
1151 ret = omapvid_init(vout, 0);
1152 if (ret) {
1153 v4l2_err(&vout->vid_dev->v4l2_dev, "failed to change mode\n");
1154 goto s_fmt_vid_out_exit;
1155 }
1156
1157 ret = 0;
1158
1159s_fmt_vid_out_exit:
1160 mutex_unlock(&vout->lock);
1161 return ret;
1162}
1163
1164static int vidioc_try_fmt_vid_overlay(struct file *file, void *fh,
1165 struct v4l2_format *f)
1166{
1167 int ret = 0;
1168 struct omap_vout_device *vout = fh;
1169 struct v4l2_window *win = &f->fmt.win;
1170
1171 ret = omap_vout_try_window(&vout->fbuf, win);
1172
1173 if (!ret) {
1174 if (vout->vid == OMAP_VIDEO1)
1175 win->global_alpha = 255;
1176 else
1177 win->global_alpha = f->fmt.win.global_alpha;
1178 }
1179
1180 return ret;
1181}
1182
1183static int vidioc_s_fmt_vid_overlay(struct file *file, void *fh,
1184 struct v4l2_format *f)
1185{
1186 int ret = 0;
1187 struct omap_overlay *ovl;
1188 struct omapvideo_info *ovid;
1189 struct omap_vout_device *vout = fh;
1190 struct v4l2_window *win = &f->fmt.win;
1191
1192 mutex_lock(&vout->lock);
1193 ovid = &vout->vid_info;
1194 ovl = ovid->overlays[0];
1195
1196 ret = omap_vout_new_window(&vout->crop, &vout->win, &vout->fbuf, win);
1197 if (!ret) {
1198 /* Video1 plane does not support global alpha */
1199 if (ovl->id == OMAP_DSS_VIDEO1)
1200 vout->win.global_alpha = 255;
1201 else
1202 vout->win.global_alpha = f->fmt.win.global_alpha;
1203
1204 vout->win.chromakey = f->fmt.win.chromakey;
1205 }
1206 mutex_unlock(&vout->lock);
1207 return ret;
1208}
1209
1210static int vidioc_enum_fmt_vid_overlay(struct file *file, void *fh,
1211 struct v4l2_fmtdesc *fmt)
1212{
1213 int index = fmt->index;
1214
1215 if (index >= NUM_OUTPUT_FORMATS)
1216 return -EINVAL;
1217
1218 fmt->flags = omap_formats[index].flags;
1219 strlcpy(fmt->description, omap_formats[index].description,
1220 sizeof(fmt->description));
1221 fmt->pixelformat = omap_formats[index].pixelformat;
1222 return 0;
1223}
1224
1225static int vidioc_g_fmt_vid_overlay(struct file *file, void *fh,
1226 struct v4l2_format *f)
1227{
1228 u32 key_value = 0;
1229 struct omap_overlay *ovl;
1230 struct omapvideo_info *ovid;
1231 struct omap_vout_device *vout = fh;
1232 struct omap_overlay_manager_info info;
1233 struct v4l2_window *win = &f->fmt.win;
1234
1235 ovid = &vout->vid_info;
1236 ovl = ovid->overlays[0];
1237
1238 win->w = vout->win.w;
1239 win->field = vout->win.field;
1240 win->global_alpha = vout->win.global_alpha;
1241
1242 if (ovl->manager && ovl->manager->get_manager_info) {
1243 ovl->manager->get_manager_info(ovl->manager, &info);
1244 key_value = info.trans_key;
1245 }
1246 win->chromakey = key_value;
1247 return 0;
1248}
1249
1250static int vidioc_cropcap(struct file *file, void *fh,
1251 struct v4l2_cropcap *cropcap)
1252{
1253 struct omap_vout_device *vout = fh;
1254 struct v4l2_pix_format *pix = &vout->pix;
1255
1256 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1257 return -EINVAL;
1258
1259 /* Width and height are always even */
1260 cropcap->bounds.width = pix->width & ~1;
1261 cropcap->bounds.height = pix->height & ~1;
1262
1263 omap_vout_default_crop(&vout->pix, &vout->fbuf, &cropcap->defrect);
1264 cropcap->pixelaspect.numerator = 1;
1265 cropcap->pixelaspect.denominator = 1;
1266 return 0;
1267}
1268
1269static int vidioc_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
1270{
1271 struct omap_vout_device *vout = fh;
1272
1273 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1274 return -EINVAL;
1275 crop->c = vout->crop;
1276 return 0;
1277}
1278
1279static int vidioc_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
1280{
1281 int ret = -EINVAL;
1282 struct omap_vout_device *vout = fh;
1283 struct omapvideo_info *ovid;
1284 struct omap_overlay *ovl;
1285 struct omap_video_timings *timing;
1286
1287 if (vout->streaming)
1288 return -EBUSY;
1289
1290 mutex_lock(&vout->lock);
1291 ovid = &vout->vid_info;
1292 ovl = ovid->overlays[0];
1293
1294 if (!ovl->manager || !ovl->manager->device) {
1295 ret = -EINVAL;
1296 goto s_crop_err;
1297 }
1298 /* get the display device attached to the overlay */
1299 timing = &ovl->manager->device->panel.timings;
1300
1301 if (is_rotation_90_or_270(vout)) {
1302 vout->fbuf.fmt.height = timing->x_res;
1303 vout->fbuf.fmt.width = timing->y_res;
1304 } else {
1305 vout->fbuf.fmt.height = timing->y_res;
1306 vout->fbuf.fmt.width = timing->x_res;
1307 }
1308
1309 if (crop->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1310 ret = omap_vout_new_crop(&vout->pix, &vout->crop, &vout->win,
1311 &vout->fbuf, &crop->c);
1312
1313s_crop_err:
1314 mutex_unlock(&vout->lock);
1315 return ret;
1316}
1317
1318static int vidioc_queryctrl(struct file *file, void *fh,
1319 struct v4l2_queryctrl *ctrl)
1320{
1321 int ret = 0;
1322
1323 switch (ctrl->id) {
1324 case V4L2_CID_ROTATE:
1325 ret = v4l2_ctrl_query_fill(ctrl, 0, 270, 90, 0);
1326 break;
1327 case V4L2_CID_BG_COLOR:
1328 ret = v4l2_ctrl_query_fill(ctrl, 0, 0xFFFFFF, 1, 0);
1329 break;
1330 case V4L2_CID_VFLIP:
1331 ret = v4l2_ctrl_query_fill(ctrl, 0, 1, 1, 0);
1332 break;
1333 default:
1334 ctrl->name[0] = '\0';
1335 ret = -EINVAL;
1336 }
1337 return ret;
1338}
1339
1340static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *ctrl)
1341{
1342 int ret = 0;
1343 struct omap_vout_device *vout = fh;
1344
1345 switch (ctrl->id) {
1346 case V4L2_CID_ROTATE:
1347 ctrl->value = vout->control[0].value;
1348 break;
1349 case V4L2_CID_BG_COLOR:
1350 {
1351 struct omap_overlay_manager_info info;
1352 struct omap_overlay *ovl;
1353
1354 ovl = vout->vid_info.overlays[0];
1355 if (!ovl->manager || !ovl->manager->get_manager_info) {
1356 ret = -EINVAL;
1357 break;
1358 }
1359
1360 ovl->manager->get_manager_info(ovl->manager, &info);
1361 ctrl->value = info.default_color;
1362 break;
1363 }
1364 case V4L2_CID_VFLIP:
1365 ctrl->value = vout->control[2].value;
1366 break;
1367 default:
1368 ret = -EINVAL;
1369 }
1370 return ret;
1371}
1372
1373static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *a)
1374{
1375 int ret = 0;
1376 struct omap_vout_device *vout = fh;
1377
1378 switch (a->id) {
1379 case V4L2_CID_ROTATE:
1380 {
1381 struct omapvideo_info *ovid;
1382 int rotation = a->value;
1383
1384 ovid = &vout->vid_info;
1385
1386 mutex_lock(&vout->lock);
1387 if (rotation && ovid->rotation_type == VOUT_ROT_NONE) {
1388 mutex_unlock(&vout->lock);
1389 ret = -ERANGE;
1390 break;
1391 }
1392
1393 if (rotation && vout->pix.pixelformat == V4L2_PIX_FMT_RGB24) {
1394 mutex_unlock(&vout->lock);
1395 ret = -EINVAL;
1396 break;
1397 }
1398
1399 if (v4l2_rot_to_dss_rot(rotation, &vout->rotation,
1400 vout->mirror)) {
1401 mutex_unlock(&vout->lock);
1402 ret = -EINVAL;
1403 break;
1404 }
1405
1406 vout->control[0].value = rotation;
1407 mutex_unlock(&vout->lock);
1408 break;
1409 }
1410 case V4L2_CID_BG_COLOR:
1411 {
1412 struct omap_overlay *ovl;
1413 unsigned int color = a->value;
1414 struct omap_overlay_manager_info info;
1415
1416 ovl = vout->vid_info.overlays[0];
1417
1418 mutex_lock(&vout->lock);
1419 if (!ovl->manager || !ovl->manager->get_manager_info) {
1420 mutex_unlock(&vout->lock);
1421 ret = -EINVAL;
1422 break;
1423 }
1424
1425 ovl->manager->get_manager_info(ovl->manager, &info);
1426 info.default_color = color;
1427 if (ovl->manager->set_manager_info(ovl->manager, &info)) {
1428 mutex_unlock(&vout->lock);
1429 ret = -EINVAL;
1430 break;
1431 }
1432
1433 vout->control[1].value = color;
1434 mutex_unlock(&vout->lock);
1435 break;
1436 }
1437 case V4L2_CID_VFLIP:
1438 {
1439 struct omap_overlay *ovl;
1440 struct omapvideo_info *ovid;
1441 unsigned int mirror = a->value;
1442
1443 ovid = &vout->vid_info;
1444 ovl = ovid->overlays[0];
1445
1446 mutex_lock(&vout->lock);
1447 if (mirror && ovid->rotation_type == VOUT_ROT_NONE) {
1448 mutex_unlock(&vout->lock);
1449 ret = -ERANGE;
1450 break;
1451 }
1452
1453 if (mirror && vout->pix.pixelformat == V4L2_PIX_FMT_RGB24) {
1454 mutex_unlock(&vout->lock);
1455 ret = -EINVAL;
1456 break;
1457 }
1458 vout->mirror = mirror;
1459 vout->control[2].value = mirror;
1460 mutex_unlock(&vout->lock);
1461 break;
1462 }
1463 default:
1464 ret = -EINVAL;
1465 }
1466 return ret;
1467}
1468
1469static int vidioc_reqbufs(struct file *file, void *fh,
1470 struct v4l2_requestbuffers *req)
1471{
1472 int ret = 0;
1473 unsigned int i, num_buffers = 0;
1474 struct omap_vout_device *vout = fh;
1475 struct videobuf_queue *q = &vout->vbq;
1476
1477 if ((req->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) || (req->count < 0))
1478 return -EINVAL;
1479 /* if memory is not mmp or userptr
1480 return error */
1481 if ((V4L2_MEMORY_MMAP != req->memory) &&
1482 (V4L2_MEMORY_USERPTR != req->memory))
1483 return -EINVAL;
1484
1485 mutex_lock(&vout->lock);
1486 /* Cannot be requested when streaming is on */
1487 if (vout->streaming) {
1488 ret = -EBUSY;
1489 goto reqbuf_err;
1490 }
1491
1492 /* If buffers are already allocated free them */
1493 if (q->bufs[0] && (V4L2_MEMORY_MMAP == q->bufs[0]->memory)) {
1494 if (vout->mmap_count) {
1495 ret = -EBUSY;
1496 goto reqbuf_err;
1497 }
1498 num_buffers = (vout->vid == OMAP_VIDEO1) ?
1499 video1_numbuffers : video2_numbuffers;
1500 for (i = num_buffers; i < vout->buffer_allocated; i++) {
1501 omap_vout_free_buffer(vout->buf_virt_addr[i],
1502 vout->buffer_size);
1503 vout->buf_virt_addr[i] = 0;
1504 vout->buf_phy_addr[i] = 0;
1505 }
1506 vout->buffer_allocated = num_buffers;
1507 videobuf_mmap_free(q);
1508 } else if (q->bufs[0] && (V4L2_MEMORY_USERPTR == q->bufs[0]->memory)) {
1509 if (vout->buffer_allocated) {
1510 videobuf_mmap_free(q);
1511 for (i = 0; i < vout->buffer_allocated; i++) {
1512 kfree(q->bufs[i]);
1513 q->bufs[i] = NULL;
1514 }
1515 vout->buffer_allocated = 0;
1516 }
1517 }
1518
1519 /*store the memory type in data structure */
1520 vout->memory = req->memory;
1521
1522 INIT_LIST_HEAD(&vout->dma_queue);
1523
1524 /* call videobuf_reqbufs api */
1525 ret = videobuf_reqbufs(q, req);
1526 if (ret < 0)
1527 goto reqbuf_err;
1528
1529 vout->buffer_allocated = req->count;
1530
1531reqbuf_err:
1532 mutex_unlock(&vout->lock);
1533 return ret;
1534}
1535
1536static int vidioc_querybuf(struct file *file, void *fh,
1537 struct v4l2_buffer *b)
1538{
1539 struct omap_vout_device *vout = fh;
1540
1541 return videobuf_querybuf(&vout->vbq, b);
1542}
1543
1544static int vidioc_qbuf(struct file *file, void *fh,
1545 struct v4l2_buffer *buffer)
1546{
1547 struct omap_vout_device *vout = fh;
1548 struct videobuf_queue *q = &vout->vbq;
1549
1550 if ((V4L2_BUF_TYPE_VIDEO_OUTPUT != buffer->type) ||
1551 (buffer->index >= vout->buffer_allocated) ||
1552 (q->bufs[buffer->index]->memory != buffer->memory)) {
1553 return -EINVAL;
1554 }
1555 if (V4L2_MEMORY_USERPTR == buffer->memory) {
1556 if ((buffer->length < vout->pix.sizeimage) ||
1557 (0 == buffer->m.userptr)) {
1558 return -EINVAL;
1559 }
1560 }
1561
1562 if ((is_rotation_enabled(vout)) &&
1563 vout->vrfb_dma_tx.req_status == DMA_CHAN_NOT_ALLOTED) {
1564 v4l2_warn(&vout->vid_dev->v4l2_dev,
1565 "DMA Channel not allocated for Rotation\n");
1566 return -EINVAL;
1567 }
1568
1569 return videobuf_qbuf(q, buffer);
1570}
1571
1572static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1573{
1574 struct omap_vout_device *vout = fh;
1575 struct videobuf_queue *q = &vout->vbq;
1576
1577 int ret;
1578 u32 addr;
1579 unsigned long size;
1580 struct videobuf_buffer *vb;
1581
1582 vb = q->bufs[b->index];
1583
1584 if (!vout->streaming)
1585 return -EINVAL;
1586
1587 if (file->f_flags & O_NONBLOCK)
1588 /* Call videobuf_dqbuf for non blocking mode */
1589 ret = videobuf_dqbuf(q, (struct v4l2_buffer *)b, 1);
1590 else
1591 /* Call videobuf_dqbuf for blocking mode */
1592 ret = videobuf_dqbuf(q, (struct v4l2_buffer *)b, 0);
1593
1594 addr = (unsigned long) vout->buf_phy_addr[vb->i];
1595 size = (unsigned long) vb->size;
1596 dma_unmap_single(vout->vid_dev->v4l2_dev.dev, addr,
1597 size, DMA_TO_DEVICE);
1598 return ret;
1599}
1600
1601static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1602{
1603 int ret = 0, j;
1604 u32 addr = 0, mask = 0;
1605 struct omap_vout_device *vout = fh;
1606 struct videobuf_queue *q = &vout->vbq;
1607 struct omapvideo_info *ovid = &vout->vid_info;
1608
1609 mutex_lock(&vout->lock);
1610
1611 if (vout->streaming) {
1612 ret = -EBUSY;
1613 goto streamon_err;
1614 }
1615
1616 ret = videobuf_streamon(q);
1617 if (ret)
1618 goto streamon_err;
1619
1620 if (list_empty(&vout->dma_queue)) {
1621 ret = -EIO;
1622 goto streamon_err1;
1623 }
1624
1625 /* Get the next frame from the buffer queue */
1626 vout->next_frm = vout->cur_frm = list_entry(vout->dma_queue.next,
1627 struct videobuf_buffer, queue);
1628 /* Remove buffer from the buffer queue */
1629 list_del(&vout->cur_frm->queue);
1630 /* Mark state of the current frame to active */
1631 vout->cur_frm->state = VIDEOBUF_ACTIVE;
1632 /* Initialize field_id and started member */
1633 vout->field_id = 0;
1634
1635 /* set flag here. Next QBUF will start DMA */
1636 vout->streaming = 1;
1637
1638 vout->first_int = 1;
1639
1640 if (omap_vout_calculate_offset(vout)) {
1641 ret = -EINVAL;
1642 goto streamon_err1;
1643 }
1644 addr = (unsigned long) vout->queued_buf_addr[vout->cur_frm->i]
1645 + vout->cropped_offset;
1646
1647 mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_EVEN | DISPC_IRQ_EVSYNC_ODD
1648 | DISPC_IRQ_VSYNC2;
1649
1650 omap_dispc_register_isr(omap_vout_isr, vout, mask);
1651
1652 for (j = 0; j < ovid->num_overlays; j++) {
1653 struct omap_overlay *ovl = ovid->overlays[j];
1654
1655 if (ovl->manager && ovl->manager->device) {
1656 struct omap_overlay_info info;
1657 ovl->get_overlay_info(ovl, &info);
1658 info.enabled = 1;
1659 info.paddr = addr;
1660 if (ovl->set_overlay_info(ovl, &info)) {
1661 ret = -EINVAL;
1662 goto streamon_err1;
1663 }
1664 }
1665 }
1666
1667 /* First save the configuration in ovelray structure */
1668 ret = omapvid_init(vout, addr);
1669 if (ret)
1670 v4l2_err(&vout->vid_dev->v4l2_dev,
1671 "failed to set overlay info\n");
1672 /* Enable the pipeline and set the Go bit */
1673 ret = omapvid_apply_changes(vout);
1674 if (ret)
1675 v4l2_err(&vout->vid_dev->v4l2_dev, "failed to change mode\n");
1676
1677 ret = 0;
1678
1679streamon_err1:
1680 if (ret)
1681 ret = videobuf_streamoff(q);
1682streamon_err:
1683 mutex_unlock(&vout->lock);
1684 return ret;
1685}
1686
1687static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1688{
1689 u32 mask = 0;
1690 int ret = 0, j;
1691 struct omap_vout_device *vout = fh;
1692 struct omapvideo_info *ovid = &vout->vid_info;
1693
1694 if (!vout->streaming)
1695 return -EINVAL;
1696
1697 vout->streaming = 0;
1698 mask = DISPC_IRQ_VSYNC | DISPC_IRQ_EVSYNC_EVEN | DISPC_IRQ_EVSYNC_ODD
1699 | DISPC_IRQ_VSYNC2;
1700
1701 omap_dispc_unregister_isr(omap_vout_isr, vout, mask);
1702
1703 for (j = 0; j < ovid->num_overlays; j++) {
1704 struct omap_overlay *ovl = ovid->overlays[j];
1705
1706 if (ovl->manager && ovl->manager->device) {
1707 struct omap_overlay_info info;
1708
1709 ovl->get_overlay_info(ovl, &info);
1710 info.enabled = 0;
1711 ret = ovl->set_overlay_info(ovl, &info);
1712 if (ret)
1713 v4l2_err(&vout->vid_dev->v4l2_dev,
1714 "failed to update overlay info in streamoff\n");
1715 }
1716 }
1717
1718 /* Turn of the pipeline */
1719 ret = omapvid_apply_changes(vout);
1720 if (ret)
1721 v4l2_err(&vout->vid_dev->v4l2_dev, "failed to change mode in"
1722 " streamoff\n");
1723
1724 INIT_LIST_HEAD(&vout->dma_queue);
1725 ret = videobuf_streamoff(&vout->vbq);
1726
1727 return ret;
1728}
1729
1730static int vidioc_s_fbuf(struct file *file, void *fh,
1731 struct v4l2_framebuffer *a)
1732{
1733 int enable = 0;
1734 struct omap_overlay *ovl;
1735 struct omapvideo_info *ovid;
1736 struct omap_vout_device *vout = fh;
1737 struct omap_overlay_manager_info info;
1738 enum omap_dss_trans_key_type key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
1739
1740 ovid = &vout->vid_info;
1741 ovl = ovid->overlays[0];
1742
1743 /* OMAP DSS doesn't support Source and Destination color
1744 key together */
1745 if ((a->flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
1746 (a->flags & V4L2_FBUF_FLAG_CHROMAKEY))
1747 return -EINVAL;
1748 /* OMAP DSS Doesn't support the Destination color key
1749 and alpha blending together */
1750 if ((a->flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
1751 (a->flags & V4L2_FBUF_FLAG_LOCAL_ALPHA))
1752 return -EINVAL;
1753
1754 if ((a->flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY)) {
1755 vout->fbuf.flags |= V4L2_FBUF_FLAG_SRC_CHROMAKEY;
1756 key_type = OMAP_DSS_COLOR_KEY_VID_SRC;
1757 } else
1758 vout->fbuf.flags &= ~V4L2_FBUF_FLAG_SRC_CHROMAKEY;
1759
1760 if ((a->flags & V4L2_FBUF_FLAG_CHROMAKEY)) {
1761 vout->fbuf.flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1762 key_type = OMAP_DSS_COLOR_KEY_GFX_DST;
1763 } else
1764 vout->fbuf.flags &= ~V4L2_FBUF_FLAG_CHROMAKEY;
1765
1766 if (a->flags & (V4L2_FBUF_FLAG_CHROMAKEY |
1767 V4L2_FBUF_FLAG_SRC_CHROMAKEY))
1768 enable = 1;
1769 else
1770 enable = 0;
1771 if (ovl->manager && ovl->manager->get_manager_info &&
1772 ovl->manager->set_manager_info) {
1773
1774 ovl->manager->get_manager_info(ovl->manager, &info);
1775 info.trans_enabled = enable;
1776 info.trans_key_type = key_type;
1777 info.trans_key = vout->win.chromakey;
1778
1779 if (ovl->manager->set_manager_info(ovl->manager, &info))
1780 return -EINVAL;
1781 }
1782 if (a->flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) {
1783 vout->fbuf.flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1784 enable = 1;
1785 } else {
1786 vout->fbuf.flags &= ~V4L2_FBUF_FLAG_LOCAL_ALPHA;
1787 enable = 0;
1788 }
1789 if (ovl->manager && ovl->manager->get_manager_info &&
1790 ovl->manager->set_manager_info) {
1791 ovl->manager->get_manager_info(ovl->manager, &info);
1792 info.alpha_enabled = enable;
1793 if (ovl->manager->set_manager_info(ovl->manager, &info))
1794 return -EINVAL;
1795 }
1796
1797 return 0;
1798}
1799
1800static int vidioc_g_fbuf(struct file *file, void *fh,
1801 struct v4l2_framebuffer *a)
1802{
1803 struct omap_overlay *ovl;
1804 struct omapvideo_info *ovid;
1805 struct omap_vout_device *vout = fh;
1806 struct omap_overlay_manager_info info;
1807
1808 ovid = &vout->vid_info;
1809 ovl = ovid->overlays[0];
1810
1811 a->flags = 0x0;
1812 a->capability = V4L2_FBUF_CAP_LOCAL_ALPHA | V4L2_FBUF_CAP_CHROMAKEY
1813 | V4L2_FBUF_CAP_SRC_CHROMAKEY;
1814
1815 if (ovl->manager && ovl->manager->get_manager_info) {
1816 ovl->manager->get_manager_info(ovl->manager, &info);
1817 if (info.trans_key_type == OMAP_DSS_COLOR_KEY_VID_SRC)
1818 a->flags |= V4L2_FBUF_FLAG_SRC_CHROMAKEY;
1819 if (info.trans_key_type == OMAP_DSS_COLOR_KEY_GFX_DST)
1820 a->flags |= V4L2_FBUF_FLAG_CHROMAKEY;
1821 }
1822 if (ovl->manager && ovl->manager->get_manager_info) {
1823 ovl->manager->get_manager_info(ovl->manager, &info);
1824 if (info.alpha_enabled)
1825 a->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
1826 }
1827
1828 return 0;
1829}
1830
1831static const struct v4l2_ioctl_ops vout_ioctl_ops = {
1832 .vidioc_querycap = vidioc_querycap,
1833 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,
1834 .vidioc_g_fmt_vid_out = vidioc_g_fmt_vid_out,
1835 .vidioc_try_fmt_vid_out = vidioc_try_fmt_vid_out,
1836 .vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
1837 .vidioc_queryctrl = vidioc_queryctrl,
1838 .vidioc_g_ctrl = vidioc_g_ctrl,
1839 .vidioc_s_fbuf = vidioc_s_fbuf,
1840 .vidioc_g_fbuf = vidioc_g_fbuf,
1841 .vidioc_s_ctrl = vidioc_s_ctrl,
1842 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
1843 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
1844 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
1845 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
1846 .vidioc_cropcap = vidioc_cropcap,
1847 .vidioc_g_crop = vidioc_g_crop,
1848 .vidioc_s_crop = vidioc_s_crop,
1849 .vidioc_reqbufs = vidioc_reqbufs,
1850 .vidioc_querybuf = vidioc_querybuf,
1851 .vidioc_qbuf = vidioc_qbuf,
1852 .vidioc_dqbuf = vidioc_dqbuf,
1853 .vidioc_streamon = vidioc_streamon,
1854 .vidioc_streamoff = vidioc_streamoff,
1855};
1856
1857static const struct v4l2_file_operations omap_vout_fops = {
1858 .owner = THIS_MODULE,
1859 .unlocked_ioctl = video_ioctl2,
1860 .mmap = omap_vout_mmap,
1861 .open = omap_vout_open,
1862 .release = omap_vout_release,
1863};
1864
1865/* Init functions used during driver initialization */
1866/* Initial setup of video_data */
1867static int __init omap_vout_setup_video_data(struct omap_vout_device *vout)
1868{
1869 struct video_device *vfd;
1870 struct v4l2_pix_format *pix;
1871 struct v4l2_control *control;
1872 struct omap_dss_device *display =
1873 vout->vid_info.overlays[0]->manager->device;
1874
1875 /* set the default pix */
1876 pix = &vout->pix;
1877
1878 /* Set the default picture of QVGA */
1879 pix->width = QQVGA_WIDTH;
1880 pix->height = QQVGA_HEIGHT;
1881
1882 /* Default pixel format is RGB 5-6-5 */
1883 pix->pixelformat = V4L2_PIX_FMT_RGB565;
1884 pix->field = V4L2_FIELD_ANY;
1885 pix->bytesperline = pix->width * 2;
1886 pix->sizeimage = pix->bytesperline * pix->height;
1887 pix->priv = 0;
1888 pix->colorspace = V4L2_COLORSPACE_JPEG;
1889
1890 vout->bpp = RGB565_BPP;
1891 vout->fbuf.fmt.width = display->panel.timings.x_res;
1892 vout->fbuf.fmt.height = display->panel.timings.y_res;
1893
1894 /* Set the data structures for the overlay parameters*/
1895 vout->win.global_alpha = 255;
1896 vout->fbuf.flags = 0;
1897 vout->fbuf.capability = V4L2_FBUF_CAP_LOCAL_ALPHA |
1898 V4L2_FBUF_CAP_SRC_CHROMAKEY | V4L2_FBUF_CAP_CHROMAKEY;
1899 vout->win.chromakey = 0;
1900
1901 omap_vout_new_format(pix, &vout->fbuf, &vout->crop, &vout->win);
1902
1903 /*Initialize the control variables for
1904 rotation, flipping and background color. */
1905 control = vout->control;
1906 control[0].id = V4L2_CID_ROTATE;
1907 control[0].value = 0;
1908 vout->rotation = 0;
1909 vout->mirror = 0;
1910 vout->control[2].id = V4L2_CID_HFLIP;
1911 vout->control[2].value = 0;
1912 if (vout->vid_info.rotation_type == VOUT_ROT_VRFB)
1913 vout->vrfb_bpp = 2;
1914
1915 control[1].id = V4L2_CID_BG_COLOR;
1916 control[1].value = 0;
1917
1918 /* initialize the video_device struct */
1919 vfd = vout->vfd = video_device_alloc();
1920
1921 if (!vfd) {
1922 printk(KERN_ERR VOUT_NAME ": could not allocate"
1923 " video device struct\n");
1924 return -ENOMEM;
1925 }
1926 vfd->release = video_device_release;
1927 vfd->ioctl_ops = &vout_ioctl_ops;
1928
1929 strlcpy(vfd->name, VOUT_NAME, sizeof(vfd->name));
1930
1931 vfd->fops = &omap_vout_fops;
1932 vfd->v4l2_dev = &vout->vid_dev->v4l2_dev;
1933 mutex_init(&vout->lock);
1934
1935 vfd->minor = -1;
1936 return 0;
1937
1938}
1939
1940/* Setup video buffers */
1941static int __init omap_vout_setup_video_bufs(struct platform_device *pdev,
1942 int vid_num)
1943{
1944 u32 numbuffers;
1945 int ret = 0, i;
1946 struct omapvideo_info *ovid;
1947 struct omap_vout_device *vout;
1948 struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
1949 struct omap2video_device *vid_dev =
1950 container_of(v4l2_dev, struct omap2video_device, v4l2_dev);
1951
1952 vout = vid_dev->vouts[vid_num];
1953 ovid = &vout->vid_info;
1954
1955 numbuffers = (vid_num == 0) ? video1_numbuffers : video2_numbuffers;
1956 vout->buffer_size = (vid_num == 0) ? video1_bufsize : video2_bufsize;
1957 dev_info(&pdev->dev, "Buffer Size = %d\n", vout->buffer_size);
1958
1959 for (i = 0; i < numbuffers; i++) {
1960 vout->buf_virt_addr[i] =
1961 omap_vout_alloc_buffer(vout->buffer_size,
1962 (u32 *) &vout->buf_phy_addr[i]);
1963 if (!vout->buf_virt_addr[i]) {
1964 numbuffers = i;
1965 ret = -ENOMEM;
1966 goto free_buffers;
1967 }
1968 }
1969
1970 vout->cropped_offset = 0;
1971
1972 if (ovid->rotation_type == VOUT_ROT_VRFB) {
1973 int static_vrfb_allocation = (vid_num == 0) ?
1974 vid1_static_vrfb_alloc : vid2_static_vrfb_alloc;
1975 ret = omap_vout_setup_vrfb_bufs(pdev, vid_num,
1976 static_vrfb_allocation);
1977 }
1978
1979 return ret;
1980
1981free_buffers:
1982 for (i = 0; i < numbuffers; i++) {
1983 omap_vout_free_buffer(vout->buf_virt_addr[i],
1984 vout->buffer_size);
1985 vout->buf_virt_addr[i] = 0;
1986 vout->buf_phy_addr[i] = 0;
1987 }
1988 return ret;
1989
1990}
1991
1992/* Create video out devices */
1993static int __init omap_vout_create_video_devices(struct platform_device *pdev)
1994{
1995 int ret = 0, k;
1996 struct omap_vout_device *vout;
1997 struct video_device *vfd = NULL;
1998 struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
1999 struct omap2video_device *vid_dev = container_of(v4l2_dev,
2000 struct omap2video_device, v4l2_dev);
2001
2002 for (k = 0; k < pdev->num_resources; k++) {
2003
2004 vout = kzalloc(sizeof(struct omap_vout_device), GFP_KERNEL);
2005 if (!vout) {
2006 dev_err(&pdev->dev, ": could not allocate memory\n");
2007 return -ENOMEM;
2008 }
2009
2010 vout->vid = k;
2011 vid_dev->vouts[k] = vout;
2012 vout->vid_dev = vid_dev;
2013 /* Select video2 if only 1 overlay is controlled by V4L2 */
2014 if (pdev->num_resources == 1)
2015 vout->vid_info.overlays[0] = vid_dev->overlays[k + 2];
2016 else
2017 /* Else select video1 and video2 one by one. */
2018 vout->vid_info.overlays[0] = vid_dev->overlays[k + 1];
2019 vout->vid_info.num_overlays = 1;
2020 vout->vid_info.id = k + 1;
2021
2022 /* Set VRFB as rotation_type for omap2 and omap3 */
2023 if (cpu_is_omap24xx() || cpu_is_omap34xx())
2024 vout->vid_info.rotation_type = VOUT_ROT_VRFB;
2025
2026 /* Setup the default configuration for the video devices
2027 */
2028 if (omap_vout_setup_video_data(vout) != 0) {
2029 ret = -ENOMEM;
2030 goto error;
2031 }
2032
2033 /* Allocate default number of buffers for the video streaming
2034 * and reserve the VRFB space for rotation
2035 */
2036 if (omap_vout_setup_video_bufs(pdev, k) != 0) {
2037 ret = -ENOMEM;
2038 goto error1;
2039 }
2040
2041 /* Register the Video device with V4L2
2042 */
2043 vfd = vout->vfd;
2044 if (video_register_device(vfd, VFL_TYPE_GRABBER, -1) < 0) {
2045 dev_err(&pdev->dev, ": Could not register "
2046 "Video for Linux device\n");
2047 vfd->minor = -1;
2048 ret = -ENODEV;
2049 goto error2;
2050 }
2051 video_set_drvdata(vfd, vout);
2052
2053 /* Configure the overlay structure */
2054 ret = omapvid_init(vid_dev->vouts[k], 0);
2055 if (!ret)
2056 goto success;
2057
2058error2:
2059 if (vout->vid_info.rotation_type == VOUT_ROT_VRFB)
2060 omap_vout_release_vrfb(vout);
2061 omap_vout_free_buffers(vout);
2062error1:
2063 video_device_release(vfd);
2064error:
2065 kfree(vout);
2066 return ret;
2067
2068success:
2069 dev_info(&pdev->dev, ": registered and initialized"
2070 " video device %d\n", vfd->minor);
2071 if (k == (pdev->num_resources - 1))
2072 return 0;
2073 }
2074
2075 return -ENODEV;
2076}
2077/* Driver functions */
2078static void omap_vout_cleanup_device(struct omap_vout_device *vout)
2079{
2080 struct video_device *vfd;
2081 struct omapvideo_info *ovid;
2082
2083 if (!vout)
2084 return;
2085
2086 vfd = vout->vfd;
2087 ovid = &vout->vid_info;
2088 if (vfd) {
2089 if (!video_is_registered(vfd)) {
2090 /*
2091 * The device was never registered, so release the
2092 * video_device struct directly.
2093 */
2094 video_device_release(vfd);
2095 } else {
2096 /*
2097 * The unregister function will release the video_device
2098 * struct as well as unregistering it.
2099 */
2100 video_unregister_device(vfd);
2101 }
2102 }
2103 if (ovid->rotation_type == VOUT_ROT_VRFB) {
2104 omap_vout_release_vrfb(vout);
2105 /* Free the VRFB buffer if allocated
2106 * init time
2107 */
2108 if (vout->vrfb_static_allocation)
2109 omap_vout_free_vrfb_buffers(vout);
2110 }
2111 omap_vout_free_buffers(vout);
2112
2113 kfree(vout);
2114}
2115
2116static int omap_vout_remove(struct platform_device *pdev)
2117{
2118 int k;
2119 struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
2120 struct omap2video_device *vid_dev = container_of(v4l2_dev, struct
2121 omap2video_device, v4l2_dev);
2122
2123 v4l2_device_unregister(v4l2_dev);
2124 for (k = 0; k < pdev->num_resources; k++)
2125 omap_vout_cleanup_device(vid_dev->vouts[k]);
2126
2127 for (k = 0; k < vid_dev->num_displays; k++) {
2128 if (vid_dev->displays[k]->state != OMAP_DSS_DISPLAY_DISABLED)
2129 vid_dev->displays[k]->driver->disable(vid_dev->displays[k]);
2130
2131 omap_dss_put_device(vid_dev->displays[k]);
2132 }
2133 kfree(vid_dev);
2134 return 0;
2135}
2136
2137static int __init omap_vout_probe(struct platform_device *pdev)
2138{
2139 int ret = 0, i;
2140 struct omap_overlay *ovl;
2141 struct omap_dss_device *dssdev = NULL;
2142 struct omap_dss_device *def_display;
2143 struct omap2video_device *vid_dev = NULL;
2144
2145 if (pdev->num_resources == 0) {
2146 dev_err(&pdev->dev, "probed for an unknown device\n");
2147 return -ENODEV;
2148 }
2149
2150 vid_dev = kzalloc(sizeof(struct omap2video_device), GFP_KERNEL);
2151 if (vid_dev == NULL)
2152 return -ENOMEM;
2153
2154 vid_dev->num_displays = 0;
2155 for_each_dss_dev(dssdev) {
2156 omap_dss_get_device(dssdev);
2157 vid_dev->displays[vid_dev->num_displays++] = dssdev;
2158 }
2159
2160 if (vid_dev->num_displays == 0) {
2161 dev_err(&pdev->dev, "no displays\n");
2162 ret = -EINVAL;
2163 goto probe_err0;
2164 }
2165
2166 vid_dev->num_overlays = omap_dss_get_num_overlays();
2167 for (i = 0; i < vid_dev->num_overlays; i++)
2168 vid_dev->overlays[i] = omap_dss_get_overlay(i);
2169
2170 vid_dev->num_managers = omap_dss_get_num_overlay_managers();
2171 for (i = 0; i < vid_dev->num_managers; i++)
2172 vid_dev->managers[i] = omap_dss_get_overlay_manager(i);
2173
2174 /* Get the Video1 overlay and video2 overlay.
2175 * Setup the Display attached to that overlays
2176 */
2177 for (i = 1; i < vid_dev->num_overlays; i++) {
2178 ovl = omap_dss_get_overlay(i);
2179 if (ovl->manager && ovl->manager->device) {
2180 def_display = ovl->manager->device;
2181 } else {
2182 dev_warn(&pdev->dev, "cannot find display\n");
2183 def_display = NULL;
2184 }
2185 if (def_display) {
2186 struct omap_dss_driver *dssdrv = def_display->driver;
2187
2188 ret = dssdrv->enable(def_display);
2189 if (ret) {
2190 /* Here we are not considering a error
2191 * as display may be enabled by frame
2192 * buffer driver
2193 */
2194 dev_warn(&pdev->dev,
2195 "'%s' Display already enabled\n",
2196 def_display->name);
2197 }
2198 }
2199 }
2200
2201 if (v4l2_device_register(&pdev->dev, &vid_dev->v4l2_dev) < 0) {
2202 dev_err(&pdev->dev, "v4l2_device_register failed\n");
2203 ret = -ENODEV;
2204 goto probe_err1;
2205 }
2206
2207 ret = omap_vout_create_video_devices(pdev);
2208 if (ret)
2209 goto probe_err2;
2210
2211 for (i = 0; i < vid_dev->num_displays; i++) {
2212 struct omap_dss_device *display = vid_dev->displays[i];
2213
2214 if (display->driver->update)
2215 display->driver->update(display, 0, 0,
2216 display->panel.timings.x_res,
2217 display->panel.timings.y_res);
2218 }
2219 return 0;
2220
2221probe_err2:
2222 v4l2_device_unregister(&vid_dev->v4l2_dev);
2223probe_err1:
2224 for (i = 1; i < vid_dev->num_overlays; i++) {
2225 def_display = NULL;
2226 ovl = omap_dss_get_overlay(i);
2227 if (ovl->manager && ovl->manager->device)
2228 def_display = ovl->manager->device;
2229
2230 if (def_display && def_display->driver)
2231 def_display->driver->disable(def_display);
2232 }
2233probe_err0:
2234 kfree(vid_dev);
2235 return ret;
2236}
2237
2238static struct platform_driver omap_vout_driver = {
2239 .driver = {
2240 .name = VOUT_NAME,
2241 },
2242 .probe = omap_vout_probe,
2243 .remove = omap_vout_remove,
2244};
2245
2246static int __init omap_vout_init(void)
2247{
2248 if (platform_driver_register(&omap_vout_driver) != 0) {
2249 printk(KERN_ERR VOUT_NAME ":Could not register Video driver\n");
2250 return -EINVAL;
2251 }
2252 return 0;
2253}
2254
2255static void omap_vout_cleanup(void)
2256{
2257 platform_driver_unregister(&omap_vout_driver);
2258}
2259
2260late_initcall(omap_vout_init);
2261module_exit(omap_vout_cleanup);
diff --git a/drivers/media/video/omap/omap_vout_vrfb.c b/drivers/media/video/omap/omap_vout_vrfb.c
new file mode 100644
index 00000000000..ebebcac4922
--- /dev/null
+++ b/drivers/media/video/omap/omap_vout_vrfb.c
@@ -0,0 +1,390 @@
1/*
2 * omap_vout_vrfb.c
3 *
4 * Copyright (C) 2010 Texas Instruments.
5 *
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.
9 *
10 */
11
12#include <linux/sched.h>
13#include <linux/platform_device.h>
14#include <linux/videodev2.h>
15
16#include <media/videobuf-dma-contig.h>
17#include <media/v4l2-device.h>
18
19#include <plat/dma.h>
20#include <plat/vrfb.h>
21
22#include "omap_voutdef.h"
23#include "omap_voutlib.h"
24
25/*
26 * Function for allocating video buffers
27 */
28static int omap_vout_allocate_vrfb_buffers(struct omap_vout_device *vout,
29 unsigned int *count, int startindex)
30{
31 int i, j;
32
33 for (i = 0; i < *count; i++) {
34 if (!vout->smsshado_virt_addr[i]) {
35 vout->smsshado_virt_addr[i] =
36 omap_vout_alloc_buffer(vout->smsshado_size,
37 &vout->smsshado_phy_addr[i]);
38 }
39 if (!vout->smsshado_virt_addr[i] && startindex != -1) {
40 if (V4L2_MEMORY_MMAP == vout->memory && i >= startindex)
41 break;
42 }
43 if (!vout->smsshado_virt_addr[i]) {
44 for (j = 0; j < i; j++) {
45 omap_vout_free_buffer(
46 vout->smsshado_virt_addr[j],
47 vout->smsshado_size);
48 vout->smsshado_virt_addr[j] = 0;
49 vout->smsshado_phy_addr[j] = 0;
50 }
51 *count = 0;
52 return -ENOMEM;
53 }
54 memset((void *) vout->smsshado_virt_addr[i], 0,
55 vout->smsshado_size);
56 }
57 return 0;
58}
59
60/*
61 * Wakes up the application once the DMA transfer to VRFB space is completed.
62 */
63static void omap_vout_vrfb_dma_tx_callback(int lch, u16 ch_status, void *data)
64{
65 struct vid_vrfb_dma *t = (struct vid_vrfb_dma *) data;
66
67 t->tx_status = 1;
68 wake_up_interruptible(&t->wait);
69}
70
71/*
72 * Free VRFB buffers
73 */
74void omap_vout_free_vrfb_buffers(struct omap_vout_device *vout)
75{
76 int j;
77
78 for (j = 0; j < VRFB_NUM_BUFS; j++) {
79 omap_vout_free_buffer(vout->smsshado_virt_addr[j],
80 vout->smsshado_size);
81 vout->smsshado_virt_addr[j] = 0;
82 vout->smsshado_phy_addr[j] = 0;
83 }
84}
85
86int omap_vout_setup_vrfb_bufs(struct platform_device *pdev, int vid_num,
87 u32 static_vrfb_allocation)
88{
89 int ret = 0, i, j;
90 struct omap_vout_device *vout;
91 struct video_device *vfd;
92 int image_width, image_height;
93 int vrfb_num_bufs = VRFB_NUM_BUFS;
94 struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
95 struct omap2video_device *vid_dev =
96 container_of(v4l2_dev, struct omap2video_device, v4l2_dev);
97
98 vout = vid_dev->vouts[vid_num];
99 vfd = vout->vfd;
100
101 for (i = 0; i < VRFB_NUM_BUFS; i++) {
102 if (omap_vrfb_request_ctx(&vout->vrfb_context[i])) {
103 dev_info(&pdev->dev, ": VRFB allocation failed\n");
104 for (j = 0; j < i; j++)
105 omap_vrfb_release_ctx(&vout->vrfb_context[j]);
106 ret = -ENOMEM;
107 goto free_buffers;
108 }
109 }
110
111 /* Calculate VRFB memory size */
112 /* allocate for worst case size */
113 image_width = VID_MAX_WIDTH / TILE_SIZE;
114 if (VID_MAX_WIDTH % TILE_SIZE)
115 image_width++;
116
117 image_width = image_width * TILE_SIZE;
118 image_height = VID_MAX_HEIGHT / TILE_SIZE;
119
120 if (VID_MAX_HEIGHT % TILE_SIZE)
121 image_height++;
122
123 image_height = image_height * TILE_SIZE;
124 vout->smsshado_size = PAGE_ALIGN(image_width * image_height * 2 * 2);
125
126 /*
127 * Request and Initialize DMA, for DMA based VRFB transfer
128 */
129 vout->vrfb_dma_tx.dev_id = OMAP_DMA_NO_DEVICE;
130 vout->vrfb_dma_tx.dma_ch = -1;
131 vout->vrfb_dma_tx.req_status = DMA_CHAN_ALLOTED;
132 ret = omap_request_dma(vout->vrfb_dma_tx.dev_id, "VRFB DMA TX",
133 omap_vout_vrfb_dma_tx_callback,
134 (void *) &vout->vrfb_dma_tx, &vout->vrfb_dma_tx.dma_ch);
135 if (ret < 0) {
136 vout->vrfb_dma_tx.req_status = DMA_CHAN_NOT_ALLOTED;
137 dev_info(&pdev->dev, ": failed to allocate DMA Channel for"
138 " video%d\n", vfd->minor);
139 }
140 init_waitqueue_head(&vout->vrfb_dma_tx.wait);
141
142 /* statically allocated the VRFB buffer is done through
143 commands line aruments */
144 if (static_vrfb_allocation) {
145 if (omap_vout_allocate_vrfb_buffers(vout, &vrfb_num_bufs, -1)) {
146 ret = -ENOMEM;
147 goto release_vrfb_ctx;
148 }
149 vout->vrfb_static_allocation = 1;
150 }
151 return 0;
152
153release_vrfb_ctx:
154 for (j = 0; j < VRFB_NUM_BUFS; j++)
155 omap_vrfb_release_ctx(&vout->vrfb_context[j]);
156free_buffers:
157 omap_vout_free_buffers(vout);
158
159 return ret;
160}
161
162/*
163 * Release the VRFB context once the module exits
164 */
165void omap_vout_release_vrfb(struct omap_vout_device *vout)
166{
167 int i;
168
169 for (i = 0; i < VRFB_NUM_BUFS; i++)
170 omap_vrfb_release_ctx(&vout->vrfb_context[i]);
171
172 if (vout->vrfb_dma_tx.req_status == DMA_CHAN_ALLOTED) {
173 vout->vrfb_dma_tx.req_status = DMA_CHAN_NOT_ALLOTED;
174 omap_free_dma(vout->vrfb_dma_tx.dma_ch);
175 }
176}
177
178/*
179 * Allocate the buffers for the VRFB space. Data is copied from V4L2
180 * buffers to the VRFB buffers using the DMA engine.
181 */
182int omap_vout_vrfb_buffer_setup(struct omap_vout_device *vout,
183 unsigned int *count, unsigned int startindex)
184{
185 int i;
186 bool yuv_mode;
187
188 if (!is_rotation_enabled(vout))
189 return 0;
190
191 /* If rotation is enabled, allocate memory for VRFB space also */
192 *count = *count > VRFB_NUM_BUFS ? VRFB_NUM_BUFS : *count;
193
194 /* Allocate the VRFB buffers only if the buffers are not
195 * allocated during init time.
196 */
197 if (!vout->vrfb_static_allocation)
198 if (omap_vout_allocate_vrfb_buffers(vout, count, startindex))
199 return -ENOMEM;
200
201 if (vout->dss_mode == OMAP_DSS_COLOR_YUV2 ||
202 vout->dss_mode == OMAP_DSS_COLOR_UYVY)
203 yuv_mode = true;
204 else
205 yuv_mode = false;
206
207 for (i = 0; i < *count; i++)
208 omap_vrfb_setup(&vout->vrfb_context[i],
209 vout->smsshado_phy_addr[i], vout->pix.width,
210 vout->pix.height, vout->bpp, yuv_mode);
211
212 return 0;
213}
214
215int omap_vout_prepare_vrfb(struct omap_vout_device *vout,
216 struct videobuf_buffer *vb)
217{
218 dma_addr_t dmabuf;
219 struct vid_vrfb_dma *tx;
220 enum dss_rotation rotation;
221 u32 dest_frame_index = 0, src_element_index = 0;
222 u32 dest_element_index = 0, src_frame_index = 0;
223 u32 elem_count = 0, frame_count = 0, pixsize = 2;
224
225 if (!is_rotation_enabled(vout))
226 return 0;
227
228 dmabuf = vout->buf_phy_addr[vb->i];
229 /* If rotation is enabled, copy input buffer into VRFB
230 * memory space using DMA. We are copying input buffer
231 * into VRFB memory space of desired angle and DSS will
232 * read image VRFB memory for 0 degree angle
233 */
234 pixsize = vout->bpp * vout->vrfb_bpp;
235 /*
236 * DMA transfer in double index mode
237 */
238
239 /* Frame index */
240 dest_frame_index = ((MAX_PIXELS_PER_LINE * pixsize) -
241 (vout->pix.width * vout->bpp)) + 1;
242
243 /* Source and destination parameters */
244 src_element_index = 0;
245 src_frame_index = 0;
246 dest_element_index = 1;
247 /* Number of elements per frame */
248 elem_count = vout->pix.width * vout->bpp;
249 frame_count = vout->pix.height;
250 tx = &vout->vrfb_dma_tx;
251 tx->tx_status = 0;
252 omap_set_dma_transfer_params(tx->dma_ch, OMAP_DMA_DATA_TYPE_S32,
253 (elem_count / 4), frame_count, OMAP_DMA_SYNC_ELEMENT,
254 tx->dev_id, 0x0);
255 /* src_port required only for OMAP1 */
256 omap_set_dma_src_params(tx->dma_ch, 0, OMAP_DMA_AMODE_POST_INC,
257 dmabuf, src_element_index, src_frame_index);
258 /*set dma source burst mode for VRFB */
259 omap_set_dma_src_burst_mode(tx->dma_ch, OMAP_DMA_DATA_BURST_16);
260 rotation = calc_rotation(vout);
261
262 /* dest_port required only for OMAP1 */
263 omap_set_dma_dest_params(tx->dma_ch, 0, OMAP_DMA_AMODE_DOUBLE_IDX,
264 vout->vrfb_context[vb->i].paddr[0], dest_element_index,
265 dest_frame_index);
266 /*set dma dest burst mode for VRFB */
267 omap_set_dma_dest_burst_mode(tx->dma_ch, OMAP_DMA_DATA_BURST_16);
268 omap_dma_set_global_params(DMA_DEFAULT_ARB_RATE, 0x20, 0);
269
270 omap_start_dma(tx->dma_ch);
271 interruptible_sleep_on_timeout(&tx->wait, VRFB_TX_TIMEOUT);
272
273 if (tx->tx_status == 0) {
274 omap_stop_dma(tx->dma_ch);
275 return -EINVAL;
276 }
277 /* Store buffers physical address into an array. Addresses
278 * from this array will be used to configure DSS */
279 vout->queued_buf_addr[vb->i] = (u8 *)
280 vout->vrfb_context[vb->i].paddr[rotation];
281 return 0;
282}
283
284/*
285 * Calculate the buffer offsets from which the streaming should
286 * start. This offset calculation is mainly required because of
287 * the VRFB 32 pixels alignment with rotation.
288 */
289void omap_vout_calculate_vrfb_offset(struct omap_vout_device *vout)
290{
291 enum dss_rotation rotation;
292 bool mirroring = vout->mirror;
293 struct v4l2_rect *crop = &vout->crop;
294 struct v4l2_pix_format *pix = &vout->pix;
295 int *cropped_offset = &vout->cropped_offset;
296 int vr_ps = 1, ps = 2, temp_ps = 2;
297 int offset = 0, ctop = 0, cleft = 0, line_length = 0;
298
299 rotation = calc_rotation(vout);
300
301 if (V4L2_PIX_FMT_YUYV == pix->pixelformat ||
302 V4L2_PIX_FMT_UYVY == pix->pixelformat) {
303 if (is_rotation_enabled(vout)) {
304 /*
305 * ps - Actual pixel size for YUYV/UYVY for
306 * VRFB/Mirroring is 4 bytes
307 * vr_ps - Virtually pixel size for YUYV/UYVY is
308 * 2 bytes
309 */
310 ps = 4;
311 vr_ps = 2;
312 } else {
313 ps = 2; /* otherwise the pixel size is 2 byte */
314 }
315 } else if (V4L2_PIX_FMT_RGB32 == pix->pixelformat) {
316 ps = 4;
317 } else if (V4L2_PIX_FMT_RGB24 == pix->pixelformat) {
318 ps = 3;
319 }
320 vout->ps = ps;
321 vout->vr_ps = vr_ps;
322
323 if (is_rotation_enabled(vout)) {
324 line_length = MAX_PIXELS_PER_LINE;
325 ctop = (pix->height - crop->height) - crop->top;
326 cleft = (pix->width - crop->width) - crop->left;
327 } else {
328 line_length = pix->width;
329 }
330 vout->line_length = line_length;
331 switch (rotation) {
332 case dss_rotation_90_degree:
333 offset = vout->vrfb_context[0].yoffset *
334 vout->vrfb_context[0].bytespp;
335 temp_ps = ps / vr_ps;
336 if (mirroring == 0) {
337 *cropped_offset = offset + line_length *
338 temp_ps * cleft + crop->top * temp_ps;
339 } else {
340 *cropped_offset = offset + line_length * temp_ps *
341 cleft + crop->top * temp_ps + (line_length *
342 ((crop->width / (vr_ps)) - 1) * ps);
343 }
344 break;
345 case dss_rotation_180_degree:
346 offset = ((MAX_PIXELS_PER_LINE * vout->vrfb_context[0].yoffset *
347 vout->vrfb_context[0].bytespp) +
348 (vout->vrfb_context[0].xoffset *
349 vout->vrfb_context[0].bytespp));
350 if (mirroring == 0) {
351 *cropped_offset = offset + (line_length * ps * ctop) +
352 (cleft / vr_ps) * ps;
353
354 } else {
355 *cropped_offset = offset + (line_length * ps * ctop) +
356 (cleft / vr_ps) * ps + (line_length *
357 (crop->height - 1) * ps);
358 }
359 break;
360 case dss_rotation_270_degree:
361 offset = MAX_PIXELS_PER_LINE * vout->vrfb_context[0].xoffset *
362 vout->vrfb_context[0].bytespp;
363 temp_ps = ps / vr_ps;
364 if (mirroring == 0) {
365 *cropped_offset = offset + line_length *
366 temp_ps * crop->left + ctop * ps;
367 } else {
368 *cropped_offset = offset + line_length *
369 temp_ps * crop->left + ctop * ps +
370 (line_length * ((crop->width / vr_ps) - 1) *
371 ps);
372 }
373 break;
374 case dss_rotation_0_degree:
375 if (mirroring == 0) {
376 *cropped_offset = (line_length * ps) *
377 crop->top + (crop->left / vr_ps) * ps;
378 } else {
379 *cropped_offset = (line_length * ps) *
380 crop->top + (crop->left / vr_ps) * ps +
381 (line_length * (crop->height - 1) * ps);
382 }
383 break;
384 default:
385 *cropped_offset = (line_length * ps * crop->top) /
386 vr_ps + (crop->left * ps) / vr_ps +
387 ((crop->width / vr_ps) - 1) * ps;
388 break;
389 }
390}
diff --git a/drivers/media/video/omap/omap_vout_vrfb.h b/drivers/media/video/omap/omap_vout_vrfb.h
new file mode 100644
index 00000000000..ffde741e059
--- /dev/null
+++ b/drivers/media/video/omap/omap_vout_vrfb.h
@@ -0,0 +1,40 @@
1/*
2 * omap_vout_vrfb.h
3 *
4 * Copyright (C) 2010 Texas Instruments.
5 *
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.
9 *
10 */
11
12#ifndef OMAP_VOUT_VRFB_H
13#define OMAP_VOUT_VRFB_H
14
15#ifdef CONFIG_VIDEO_OMAP2_VOUT_VRFB
16void omap_vout_free_vrfb_buffers(struct omap_vout_device *vout);
17int omap_vout_setup_vrfb_bufs(struct platform_device *pdev, int vid_num,
18 u32 static_vrfb_allocation);
19void omap_vout_release_vrfb(struct omap_vout_device *vout);
20int omap_vout_vrfb_buffer_setup(struct omap_vout_device *vout,
21 unsigned int *count, unsigned int startindex);
22int omap_vout_prepare_vrfb(struct omap_vout_device *vout,
23 struct videobuf_buffer *vb);
24void omap_vout_calculate_vrfb_offset(struct omap_vout_device *vout);
25#else
26void omap_vout_free_vrfb_buffers(struct omap_vout_device *vout) { }
27int omap_vout_setup_vrfb_bufs(struct platform_device *pdev, int vid_num,
28 u32 static_vrfb_allocation)
29 { return 0; }
30void omap_vout_release_vrfb(struct omap_vout_device *vout) { }
31int omap_vout_vrfb_buffer_setup(struct omap_vout_device *vout,
32 unsigned int *count, unsigned int startindex)
33 { return 0; }
34int omap_vout_prepare_vrfb(struct omap_vout_device *vout,
35 struct videobuf_buffer *vb)
36 { return 0; }
37void omap_vout_calculate_vrfb_offset(struct omap_vout_device *vout) { }
38#endif
39
40#endif
diff --git a/drivers/media/video/omap/omap_voutdef.h b/drivers/media/video/omap/omap_voutdef.h
new file mode 100644
index 00000000000..d793501cafc
--- /dev/null
+++ b/drivers/media/video/omap/omap_voutdef.h
@@ -0,0 +1,225 @@
1/*
2 * omap_voutdef.h
3 *
4 * Copyright (C) 2010 Texas Instruments.
5 *
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.
9 */
10
11#ifndef OMAP_VOUTDEF_H
12#define OMAP_VOUTDEF_H
13
14#include <video/omapdss.h>
15#include <plat/vrfb.h>
16
17#define YUYV_BPP 2
18#define RGB565_BPP 2
19#define RGB24_BPP 3
20#define RGB32_BPP 4
21#define TILE_SIZE 32
22#define YUYV_VRFB_BPP 2
23#define RGB_VRFB_BPP 1
24#define MAX_CID 3
25#define MAC_VRFB_CTXS 4
26#define MAX_VOUT_DEV 2
27#define MAX_OVLS 3
28#define MAX_DISPLAYS 3
29#define MAX_MANAGERS 3
30
31#define QQVGA_WIDTH 160
32#define QQVGA_HEIGHT 120
33
34/* Max Resolution supported by the driver */
35#define VID_MAX_WIDTH 1280 /* Largest width */
36#define VID_MAX_HEIGHT 720 /* Largest height */
37
38/* Mimimum requirement is 2x2 for DSS */
39#define VID_MIN_WIDTH 2
40#define VID_MIN_HEIGHT 2
41
42/* 2048 x 2048 is max res supported by OMAP display controller */
43#define MAX_PIXELS_PER_LINE 2048
44
45#define VRFB_TX_TIMEOUT 1000
46#define VRFB_NUM_BUFS 4
47
48/* Max buffer size tobe allocated during init */
49#define OMAP_VOUT_MAX_BUF_SIZE (VID_MAX_WIDTH*VID_MAX_HEIGHT*4)
50
51enum dma_channel_state {
52 DMA_CHAN_NOT_ALLOTED,
53 DMA_CHAN_ALLOTED,
54};
55
56/* Enum for Rotation
57 * DSS understands rotation in 0, 1, 2, 3 context
58 * while V4L2 driver understands it as 0, 90, 180, 270
59 */
60enum dss_rotation {
61 dss_rotation_0_degree = 0,
62 dss_rotation_90_degree = 1,
63 dss_rotation_180_degree = 2,
64 dss_rotation_270_degree = 3,
65};
66
67/* Enum for choosing rotation type for vout
68 * DSS2 doesn't understand no rotation as an
69 * option while V4L2 driver doesn't support
70 * rotation in the case where VRFB is not built in
71 * the kernel
72 */
73enum vout_rotaion_type {
74 VOUT_ROT_NONE = 0,
75 VOUT_ROT_VRFB = 1,
76};
77
78/*
79 * This structure is used to store the DMA transfer parameters
80 * for VRFB hidden buffer
81 */
82struct vid_vrfb_dma {
83 int dev_id;
84 int dma_ch;
85 int req_status;
86 int tx_status;
87 wait_queue_head_t wait;
88};
89
90struct omapvideo_info {
91 int id;
92 int num_overlays;
93 struct omap_overlay *overlays[MAX_OVLS];
94 enum vout_rotaion_type rotation_type;
95};
96
97struct omap2video_device {
98 struct mutex mtx;
99
100 int state;
101
102 struct v4l2_device v4l2_dev;
103 struct omap_vout_device *vouts[MAX_VOUT_DEV];
104
105 int num_displays;
106 struct omap_dss_device *displays[MAX_DISPLAYS];
107 int num_overlays;
108 struct omap_overlay *overlays[MAX_OVLS];
109 int num_managers;
110 struct omap_overlay_manager *managers[MAX_MANAGERS];
111};
112
113/* per-device data structure */
114struct omap_vout_device {
115
116 struct omapvideo_info vid_info;
117 struct video_device *vfd;
118 struct omap2video_device *vid_dev;
119 int vid;
120 int opened;
121
122 /* we don't allow to change image fmt/size once buffer has
123 * been allocated
124 */
125 int buffer_allocated;
126 /* allow to reuse previously allocated buffer which is big enough */
127 int buffer_size;
128 /* keep buffer info across opens */
129 unsigned long buf_virt_addr[VIDEO_MAX_FRAME];
130 unsigned long buf_phy_addr[VIDEO_MAX_FRAME];
131 enum omap_color_mode dss_mode;
132
133 /* we don't allow to request new buffer when old buffers are
134 * still mmaped
135 */
136 int mmap_count;
137
138 spinlock_t vbq_lock; /* spinlock for videobuf queues */
139 unsigned long field_count; /* field counter for videobuf_buffer */
140
141 /* non-NULL means streaming is in progress. */
142 bool streaming;
143
144 struct v4l2_pix_format pix;
145 struct v4l2_rect crop;
146 struct v4l2_window win;
147 struct v4l2_framebuffer fbuf;
148
149 /* Lock to protect the shared data structures in ioctl */
150 struct mutex lock;
151
152 /* V4L2 control structure for different control id */
153 struct v4l2_control control[MAX_CID];
154 enum dss_rotation rotation;
155 bool mirror;
156 int flicker_filter;
157 /* V4L2 control structure for different control id */
158
159 int bpp; /* bytes per pixel */
160 int vrfb_bpp; /* bytes per pixel with respect to VRFB */
161
162 struct vid_vrfb_dma vrfb_dma_tx;
163 unsigned int smsshado_phy_addr[MAC_VRFB_CTXS];
164 unsigned int smsshado_virt_addr[MAC_VRFB_CTXS];
165 struct vrfb vrfb_context[MAC_VRFB_CTXS];
166 bool vrfb_static_allocation;
167 unsigned int smsshado_size;
168 unsigned char pos;
169
170 int ps, vr_ps, line_length, first_int, field_id;
171 enum v4l2_memory memory;
172 struct videobuf_buffer *cur_frm, *next_frm;
173 struct list_head dma_queue;
174 u8 *queued_buf_addr[VIDEO_MAX_FRAME];
175 u32 cropped_offset;
176 s32 tv_field1_offset;
177 void *isr_handle;
178
179 /* Buffer queue variables */
180 struct omap_vout_device *vout;
181 enum v4l2_buf_type type;
182 struct videobuf_queue vbq;
183 int io_allowed;
184
185};
186
187/*
188 * Return true if rotation is 90 or 270
189 */
190static inline int is_rotation_90_or_270(const struct omap_vout_device *vout)
191{
192 return (vout->rotation == dss_rotation_90_degree ||
193 vout->rotation == dss_rotation_270_degree);
194}
195
196/*
197 * Return true if rotation is enabled
198 */
199static inline int is_rotation_enabled(const struct omap_vout_device *vout)
200{
201 return vout->rotation || vout->mirror;
202}
203
204/*
205 * Reverse the rotation degree if mirroring is enabled
206 */
207static inline int calc_rotation(const struct omap_vout_device *vout)
208{
209 if (!vout->mirror)
210 return vout->rotation;
211
212 switch (vout->rotation) {
213 case dss_rotation_90_degree:
214 return dss_rotation_270_degree;
215 case dss_rotation_270_degree:
216 return dss_rotation_90_degree;
217 case dss_rotation_180_degree:
218 return dss_rotation_0_degree;
219 default:
220 return dss_rotation_180_degree;
221 }
222}
223
224void omap_vout_free_buffers(struct omap_vout_device *vout);
225#endif /* ifndef OMAP_VOUTDEF_H */
diff --git a/drivers/media/video/omap/omap_voutlib.c b/drivers/media/video/omap/omap_voutlib.c
new file mode 100644
index 00000000000..115408b9274
--- /dev/null
+++ b/drivers/media/video/omap/omap_voutlib.c
@@ -0,0 +1,339 @@
1/*
2 * omap_voutlib.c
3 *
4 * Copyright (C) 2005-2010 Texas Instruments.
5 *
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.
9 *
10 * Based on the OMAP2 camera driver
11 * Video-for-Linux (Version 2) camera capture driver for
12 * the OMAP24xx camera controller.
13 *
14 * Author: Andy Lowe (source@mvista.com)
15 *
16 * Copyright (C) 2004 MontaVista Software, Inc.
17 * Copyright (C) 2010 Texas Instruments.
18 *
19 */
20
21#include <linux/module.h>
22#include <linux/errno.h>
23#include <linux/kernel.h>
24#include <linux/types.h>
25#include <linux/videodev2.h>
26
27#include <linux/dma-mapping.h>
28
29#include <plat/cpu.h>
30
31#include "omap_voutlib.h"
32
33MODULE_AUTHOR("Texas Instruments");
34MODULE_DESCRIPTION("OMAP Video library");
35MODULE_LICENSE("GPL");
36
37/* Return the default overlay cropping rectangle in crop given the image
38 * size in pix and the video display size in fbuf. The default
39 * cropping rectangle is the largest rectangle no larger than the capture size
40 * that will fit on the display. The default cropping rectangle is centered in
41 * the image. All dimensions and offsets are rounded down to even numbers.
42 */
43void omap_vout_default_crop(struct v4l2_pix_format *pix,
44 struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop)
45{
46 crop->width = (pix->width < fbuf->fmt.width) ?
47 pix->width : fbuf->fmt.width;
48 crop->height = (pix->height < fbuf->fmt.height) ?
49 pix->height : fbuf->fmt.height;
50 crop->width &= ~1;
51 crop->height &= ~1;
52 crop->left = ((pix->width - crop->width) >> 1) & ~1;
53 crop->top = ((pix->height - crop->height) >> 1) & ~1;
54}
55EXPORT_SYMBOL_GPL(omap_vout_default_crop);
56
57/* Given a new render window in new_win, adjust the window to the
58 * nearest supported configuration. The adjusted window parameters are
59 * returned in new_win.
60 * Returns zero if successful, or -EINVAL if the requested window is
61 * impossible and cannot reasonably be adjusted.
62 */
63int omap_vout_try_window(struct v4l2_framebuffer *fbuf,
64 struct v4l2_window *new_win)
65{
66 struct v4l2_rect try_win;
67
68 /* make a working copy of the new_win rectangle */
69 try_win = new_win->w;
70
71 /* adjust the preview window so it fits on the display by clipping any
72 * offscreen areas
73 */
74 if (try_win.left < 0) {
75 try_win.width += try_win.left;
76 try_win.left = 0;
77 }
78 if (try_win.top < 0) {
79 try_win.height += try_win.top;
80 try_win.top = 0;
81 }
82 try_win.width = (try_win.width < fbuf->fmt.width) ?
83 try_win.width : fbuf->fmt.width;
84 try_win.height = (try_win.height < fbuf->fmt.height) ?
85 try_win.height : fbuf->fmt.height;
86 if (try_win.left + try_win.width > fbuf->fmt.width)
87 try_win.width = fbuf->fmt.width - try_win.left;
88 if (try_win.top + try_win.height > fbuf->fmt.height)
89 try_win.height = fbuf->fmt.height - try_win.top;
90 try_win.width &= ~1;
91 try_win.height &= ~1;
92
93 if (try_win.width <= 0 || try_win.height <= 0)
94 return -EINVAL;
95
96 /* We now have a valid preview window, so go with it */
97 new_win->w = try_win;
98 new_win->field = V4L2_FIELD_ANY;
99 return 0;
100}
101EXPORT_SYMBOL_GPL(omap_vout_try_window);
102
103/* Given a new render window in new_win, adjust the window to the
104 * nearest supported configuration. The image cropping window in crop
105 * will also be adjusted if necessary. Preference is given to keeping the
106 * the window as close to the requested configuration as possible. If
107 * successful, new_win, vout->win, and crop are updated.
108 * Returns zero if successful, or -EINVAL if the requested preview window is
109 * impossible and cannot reasonably be adjusted.
110 */
111int omap_vout_new_window(struct v4l2_rect *crop,
112 struct v4l2_window *win, struct v4l2_framebuffer *fbuf,
113 struct v4l2_window *new_win)
114{
115 int err;
116
117 err = omap_vout_try_window(fbuf, new_win);
118 if (err)
119 return err;
120
121 /* update our preview window */
122 win->w = new_win->w;
123 win->field = new_win->field;
124 win->chromakey = new_win->chromakey;
125
126 /* Adjust the cropping window to allow for resizing limitation */
127 if (cpu_is_omap24xx()) {
128 /* For 24xx limit is 8x to 1/2x scaling. */
129 if ((crop->height/win->w.height) >= 2)
130 crop->height = win->w.height * 2;
131
132 if ((crop->width/win->w.width) >= 2)
133 crop->width = win->w.width * 2;
134
135 if (crop->width > 768) {
136 /* The OMAP2420 vertical resizing line buffer is 768
137 * pixels wide. If the cropped image is wider than
138 * 768 pixels then it cannot be vertically resized.
139 */
140 if (crop->height != win->w.height)
141 crop->width = 768;
142 }
143 } else if (cpu_is_omap34xx()) {
144 /* For 34xx limit is 8x to 1/4x scaling. */
145 if ((crop->height/win->w.height) >= 4)
146 crop->height = win->w.height * 4;
147
148 if ((crop->width/win->w.width) >= 4)
149 crop->width = win->w.width * 4;
150 }
151 return 0;
152}
153EXPORT_SYMBOL_GPL(omap_vout_new_window);
154
155/* Given a new cropping rectangle in new_crop, adjust the cropping rectangle to
156 * the nearest supported configuration. The image render window in win will
157 * also be adjusted if necessary. The preview window is adjusted such that the
158 * horizontal and vertical rescaling ratios stay constant. If the render
159 * window would fall outside the display boundaries, the cropping rectangle
160 * will also be adjusted to maintain the rescaling ratios. If successful, crop
161 * and win are updated.
162 * Returns zero if successful, or -EINVAL if the requested cropping rectangle is
163 * impossible and cannot reasonably be adjusted.
164 */
165int omap_vout_new_crop(struct v4l2_pix_format *pix,
166 struct v4l2_rect *crop, struct v4l2_window *win,
167 struct v4l2_framebuffer *fbuf, const struct v4l2_rect *new_crop)
168{
169 struct v4l2_rect try_crop;
170 unsigned long vresize, hresize;
171
172 /* make a working copy of the new_crop rectangle */
173 try_crop = *new_crop;
174
175 /* adjust the cropping rectangle so it fits in the image */
176 if (try_crop.left < 0) {
177 try_crop.width += try_crop.left;
178 try_crop.left = 0;
179 }
180 if (try_crop.top < 0) {
181 try_crop.height += try_crop.top;
182 try_crop.top = 0;
183 }
184 try_crop.width = (try_crop.width < pix->width) ?
185 try_crop.width : pix->width;
186 try_crop.height = (try_crop.height < pix->height) ?
187 try_crop.height : pix->height;
188 if (try_crop.left + try_crop.width > pix->width)
189 try_crop.width = pix->width - try_crop.left;
190 if (try_crop.top + try_crop.height > pix->height)
191 try_crop.height = pix->height - try_crop.top;
192
193 try_crop.width &= ~1;
194 try_crop.height &= ~1;
195
196 if (try_crop.width <= 0 || try_crop.height <= 0)
197 return -EINVAL;
198
199 if (cpu_is_omap24xx()) {
200 if (try_crop.height != win->w.height) {
201 /* If we're resizing vertically, we can't support a
202 * crop width wider than 768 pixels.
203 */
204 if (try_crop.width > 768)
205 try_crop.width = 768;
206 }
207 }
208 /* vertical resizing */
209 vresize = (1024 * try_crop.height) / win->w.height;
210 if (cpu_is_omap24xx() && (vresize > 2048))
211 vresize = 2048;
212 else if (cpu_is_omap34xx() && (vresize > 4096))
213 vresize = 4096;
214
215 win->w.height = ((1024 * try_crop.height) / vresize) & ~1;
216 if (win->w.height == 0)
217 win->w.height = 2;
218 if (win->w.height + win->w.top > fbuf->fmt.height) {
219 /* We made the preview window extend below the bottom of the
220 * display, so clip it to the display boundary and resize the
221 * cropping height to maintain the vertical resizing ratio.
222 */
223 win->w.height = (fbuf->fmt.height - win->w.top) & ~1;
224 if (try_crop.height == 0)
225 try_crop.height = 2;
226 }
227 /* horizontal resizing */
228 hresize = (1024 * try_crop.width) / win->w.width;
229 if (cpu_is_omap24xx() && (hresize > 2048))
230 hresize = 2048;
231 else if (cpu_is_omap34xx() && (hresize > 4096))
232 hresize = 4096;
233
234 win->w.width = ((1024 * try_crop.width) / hresize) & ~1;
235 if (win->w.width == 0)
236 win->w.width = 2;
237 if (win->w.width + win->w.left > fbuf->fmt.width) {
238 /* We made the preview window extend past the right side of the
239 * display, so clip it to the display boundary and resize the
240 * cropping width to maintain the horizontal resizing ratio.
241 */
242 win->w.width = (fbuf->fmt.width - win->w.left) & ~1;
243 if (try_crop.width == 0)
244 try_crop.width = 2;
245 }
246 if (cpu_is_omap24xx()) {
247 if ((try_crop.height/win->w.height) >= 2)
248 try_crop.height = win->w.height * 2;
249
250 if ((try_crop.width/win->w.width) >= 2)
251 try_crop.width = win->w.width * 2;
252
253 if (try_crop.width > 768) {
254 /* The OMAP2420 vertical resizing line buffer is
255 * 768 pixels wide. If the cropped image is wider
256 * than 768 pixels then it cannot be vertically resized.
257 */
258 if (try_crop.height != win->w.height)
259 try_crop.width = 768;
260 }
261 } else if (cpu_is_omap34xx()) {
262 if ((try_crop.height/win->w.height) >= 4)
263 try_crop.height = win->w.height * 4;
264
265 if ((try_crop.width/win->w.width) >= 4)
266 try_crop.width = win->w.width * 4;
267 }
268 /* update our cropping rectangle and we're done */
269 *crop = try_crop;
270 return 0;
271}
272EXPORT_SYMBOL_GPL(omap_vout_new_crop);
273
274/* Given a new format in pix and fbuf, crop and win
275 * structures are initialized to default values. crop
276 * is initialized to the largest window size that will fit on the display. The
277 * crop window is centered in the image. win is initialized to
278 * the same size as crop and is centered on the display.
279 * All sizes and offsets are constrained to be even numbers.
280 */
281void omap_vout_new_format(struct v4l2_pix_format *pix,
282 struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop,
283 struct v4l2_window *win)
284{
285 /* crop defines the preview source window in the image capture
286 * buffer
287 */
288 omap_vout_default_crop(pix, fbuf, crop);
289
290 /* win defines the preview target window on the display */
291 win->w.width = crop->width;
292 win->w.height = crop->height;
293 win->w.left = ((fbuf->fmt.width - win->w.width) >> 1) & ~1;
294 win->w.top = ((fbuf->fmt.height - win->w.height) >> 1) & ~1;
295}
296EXPORT_SYMBOL_GPL(omap_vout_new_format);
297
298/*
299 * Allocate buffers
300 */
301unsigned long omap_vout_alloc_buffer(u32 buf_size, u32 *phys_addr)
302{
303 u32 order, size;
304 unsigned long virt_addr, addr;
305
306 size = PAGE_ALIGN(buf_size);
307 order = get_order(size);
308 virt_addr = __get_free_pages(GFP_KERNEL, order);
309 addr = virt_addr;
310
311 if (virt_addr) {
312 while (size > 0) {
313 SetPageReserved(virt_to_page(addr));
314 addr += PAGE_SIZE;
315 size -= PAGE_SIZE;
316 }
317 }
318 *phys_addr = (u32) virt_to_phys((void *) virt_addr);
319 return virt_addr;
320}
321
322/*
323 * Free buffers
324 */
325void omap_vout_free_buffer(unsigned long virtaddr, u32 buf_size)
326{
327 u32 order, size;
328 unsigned long addr = virtaddr;
329
330 size = PAGE_ALIGN(buf_size);
331 order = get_order(size);
332
333 while (size > 0) {
334 ClearPageReserved(virt_to_page(addr));
335 addr += PAGE_SIZE;
336 size -= PAGE_SIZE;
337 }
338 free_pages((unsigned long) virtaddr, order);
339}
diff --git a/drivers/media/video/omap/omap_voutlib.h b/drivers/media/video/omap/omap_voutlib.h
new file mode 100644
index 00000000000..e51750a597e
--- /dev/null
+++ b/drivers/media/video/omap/omap_voutlib.h
@@ -0,0 +1,36 @@
1/*
2 * omap_voutlib.h
3 *
4 * Copyright (C) 2010 Texas Instruments.
5 *
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.
9 *
10 */
11
12#ifndef OMAP_VOUTLIB_H
13#define OMAP_VOUTLIB_H
14
15void omap_vout_default_crop(struct v4l2_pix_format *pix,
16 struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop);
17
18int omap_vout_new_crop(struct v4l2_pix_format *pix,
19 struct v4l2_rect *crop, struct v4l2_window *win,
20 struct v4l2_framebuffer *fbuf,
21 const struct v4l2_rect *new_crop);
22
23int omap_vout_try_window(struct v4l2_framebuffer *fbuf,
24 struct v4l2_window *new_win);
25
26int omap_vout_new_window(struct v4l2_rect *crop,
27 struct v4l2_window *win, struct v4l2_framebuffer *fbuf,
28 struct v4l2_window *new_win);
29
30void omap_vout_new_format(struct v4l2_pix_format *pix,
31 struct v4l2_framebuffer *fbuf, struct v4l2_rect *crop,
32 struct v4l2_window *win);
33unsigned long omap_vout_alloc_buffer(u32 buf_size, u32 *phys_addr);
34void omap_vout_free_buffer(unsigned long virtaddr, u32 buf_size);
35#endif /* #ifndef OMAP_VOUTLIB_H */
36
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-23 08:50:05 -0400