2 * Zoran zr36057/zr36067 PCI controller driver, for the
3 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
4 * Media Labs LML33/LML33R10.
6 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
8 * Changes for BUZ by Wolfgang Scherr <scherr@net4you.net>
10 * Changes for DC10/DC30 by Laurent Pinchart <laurent.pinchart@skynet.be>
12 * Changes for LML33R10 by Maxim Yevtyushkin <max@linuxmedialabs.com>
14 * Changes for videodev2/v4l2 by Ronald Bultje <rbultje@ronald.bitfreak.net>
19 * Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net>
21 * Iomega Buz driver version 1.0
22 * Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de>
25 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
27 * bttv - Bt848 frame grabber driver
28 * Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de)
29 * & Marcus Metzler (mocm@thp.uni-koeln.de)
32 * This program is free software; you can redistribute it and/or modify
33 * it under the terms of the GNU General Public License as published by
34 * the Free Software Foundation; either version 2 of the License, or
35 * (at your option) any later version.
37 * This program is distributed in the hope that it will be useful,
38 * but WITHOUT ANY WARRANTY; without even the implied warranty of
39 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
40 * GNU General Public License for more details.
42 * You should have received a copy of the GNU General Public License
43 * along with this program; if not, write to the Free Software
44 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
47 #include <linux/version.h>
48 #include <linux/init.h>
49 #include <linux/module.h>
50 #include <linux/delay.h>
51 #include <linux/slab.h>
52 #include <linux/pci.h>
53 #include <linux/vmalloc.h>
54 #include <linux/wait.h>
56 #include <linux/interrupt.h>
57 #include <linux/i2c.h>
58 #include <linux/i2c-algo-bit.h>
60 #include <linux/spinlock.h>
62 #include <linux/videodev.h>
63 #include <media/v4l2-common.h>
64 #include <media/v4l2-ioctl.h>
65 #include "videocodec.h"
67 #include <asm/byteorder.h>
69 #include <asm/uaccess.h>
70 #include <linux/proc_fs.h>
72 #include <linux/mutex.h>
74 #include "zoran_device.h"
75 #include "zoran_card.h"
78 const struct zoran_format zoran_formats
[] = {
80 .name
= "15-bit RGB LE",
81 .fourcc
= V4L2_PIX_FMT_RGB555
,
82 .colorspace
= V4L2_COLORSPACE_SRGB
,
84 .flags
= ZORAN_FORMAT_CAPTURE
|
86 .vfespfr
= ZR36057_VFESPFR_RGB555
|ZR36057_VFESPFR_ErrDif
|
87 ZR36057_VFESPFR_LittleEndian
,
89 .name
= "15-bit RGB BE",
90 .fourcc
= V4L2_PIX_FMT_RGB555X
,
91 .colorspace
= V4L2_COLORSPACE_SRGB
,
93 .flags
= ZORAN_FORMAT_CAPTURE
|
95 .vfespfr
= ZR36057_VFESPFR_RGB555
|ZR36057_VFESPFR_ErrDif
,
97 .name
= "16-bit RGB LE",
98 .fourcc
= V4L2_PIX_FMT_RGB565
,
99 .colorspace
= V4L2_COLORSPACE_SRGB
,
101 .flags
= ZORAN_FORMAT_CAPTURE
|
102 ZORAN_FORMAT_OVERLAY
,
103 .vfespfr
= ZR36057_VFESPFR_RGB565
|ZR36057_VFESPFR_ErrDif
|
104 ZR36057_VFESPFR_LittleEndian
,
106 .name
= "16-bit RGB BE",
107 .fourcc
= V4L2_PIX_FMT_RGB565X
,
108 .colorspace
= V4L2_COLORSPACE_SRGB
,
110 .flags
= ZORAN_FORMAT_CAPTURE
|
111 ZORAN_FORMAT_OVERLAY
,
112 .vfespfr
= ZR36057_VFESPFR_RGB565
|ZR36057_VFESPFR_ErrDif
,
114 .name
= "24-bit RGB",
115 .fourcc
= V4L2_PIX_FMT_BGR24
,
116 .colorspace
= V4L2_COLORSPACE_SRGB
,
118 .flags
= ZORAN_FORMAT_CAPTURE
|
119 ZORAN_FORMAT_OVERLAY
,
120 .vfespfr
= ZR36057_VFESPFR_RGB888
|ZR36057_VFESPFR_Pack24
,
122 .name
= "32-bit RGB LE",
123 .fourcc
= V4L2_PIX_FMT_BGR32
,
124 .colorspace
= V4L2_COLORSPACE_SRGB
,
126 .flags
= ZORAN_FORMAT_CAPTURE
|
127 ZORAN_FORMAT_OVERLAY
,
128 .vfespfr
= ZR36057_VFESPFR_RGB888
|ZR36057_VFESPFR_LittleEndian
,
130 .name
= "32-bit RGB BE",
131 .fourcc
= V4L2_PIX_FMT_RGB32
,
132 .colorspace
= V4L2_COLORSPACE_SRGB
,
134 .flags
= ZORAN_FORMAT_CAPTURE
|
135 ZORAN_FORMAT_OVERLAY
,
136 .vfespfr
= ZR36057_VFESPFR_RGB888
,
138 .name
= "4:2:2, packed, YUYV",
139 .fourcc
= V4L2_PIX_FMT_YUYV
,
140 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
142 .flags
= ZORAN_FORMAT_CAPTURE
|
143 ZORAN_FORMAT_OVERLAY
,
144 .vfespfr
= ZR36057_VFESPFR_YUV422
,
146 .name
= "4:2:2, packed, UYVY",
147 .fourcc
= V4L2_PIX_FMT_UYVY
,
148 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
150 .flags
= ZORAN_FORMAT_CAPTURE
|
151 ZORAN_FORMAT_OVERLAY
,
152 .vfespfr
= ZR36057_VFESPFR_YUV422
|ZR36057_VFESPFR_LittleEndian
,
154 .name
= "Hardware-encoded Motion-JPEG",
155 .fourcc
= V4L2_PIX_FMT_MJPEG
,
156 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
158 .flags
= ZORAN_FORMAT_CAPTURE
|
159 ZORAN_FORMAT_PLAYBACK
|
160 ZORAN_FORMAT_COMPRESSED
,
163 #define NUM_FORMATS ARRAY_SIZE(zoran_formats)
165 /* small helper function for calculating buffersizes for v4l2
166 * we calculate the nearest higher power-of-two, which
167 * will be the recommended buffersize */
169 zoran_v4l2_calc_bufsize (struct zoran_jpg_settings
*settings
)
171 __u8 div
= settings
->VerDcm
* settings
->HorDcm
* settings
->TmpDcm
;
172 __u32 num
= (1024 * 512) / (div
);
181 if (result
> jpg_bufsize
)
188 /* forward references */
189 static void v4l_fbuffer_free(struct zoran_fh
*fh
);
190 static void jpg_fbuffer_free(struct zoran_fh
*fh
);
192 /* Set mapping mode */
193 static void map_mode_raw(struct zoran_fh
*fh
)
195 fh
->map_mode
= ZORAN_MAP_MODE_RAW
;
196 fh
->buffers
.buffer_size
= v4l_bufsize
;
197 fh
->buffers
.num_buffers
= v4l_nbufs
;
199 static void map_mode_jpg(struct zoran_fh
*fh
, int play
)
201 fh
->map_mode
= play
? ZORAN_MAP_MODE_JPG_PLAY
: ZORAN_MAP_MODE_JPG_REC
;
202 fh
->buffers
.buffer_size
= jpg_bufsize
;
203 fh
->buffers
.num_buffers
= jpg_nbufs
;
205 static inline const char *mode_name(enum zoran_map_mode mode
)
207 return mode
== ZORAN_MAP_MODE_RAW
? "V4L" : "JPG";
211 * Allocate the V4L grab buffers
213 * These have to be pysically contiguous.
216 static int v4l_fbuffer_alloc(struct zoran_fh
*fh
)
218 struct zoran
*zr
= fh
->zr
;
222 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
223 if (fh
->buffers
.buffer
[i
].v4l
.fbuffer
)
226 "%s: %s - buffer %d already allocated!?\n",
227 ZR_DEVNAME(zr
), __func__
, i
);
230 mem
= kmalloc(fh
->buffers
.buffer_size
,
231 GFP_KERNEL
| __GFP_NOWARN
);
235 "%s: %s - kmalloc for V4L buf %d failed\n",
236 ZR_DEVNAME(zr
), __func__
, i
);
237 v4l_fbuffer_free(fh
);
240 fh
->buffers
.buffer
[i
].v4l
.fbuffer
= mem
;
241 fh
->buffers
.buffer
[i
].v4l
.fbuffer_phys
= virt_to_phys(mem
);
242 fh
->buffers
.buffer
[i
].v4l
.fbuffer_bus
= virt_to_bus(mem
);
243 for (off
= 0; off
< fh
->buffers
.buffer_size
;
245 SetPageReserved(virt_to_page(mem
+ off
));
248 "%s: %s - V4L frame %d mem 0x%lx (bus: 0x%llx)\n",
249 ZR_DEVNAME(zr
), __func__
, i
, (unsigned long) mem
,
250 (unsigned long long)virt_to_bus(mem
));
253 fh
->buffers
.allocated
= 1;
258 /* free the V4L grab buffers */
259 static void v4l_fbuffer_free(struct zoran_fh
*fh
)
261 struct zoran
*zr
= fh
->zr
;
265 dprintk(4, KERN_INFO
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
267 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
268 if (!fh
->buffers
.buffer
[i
].v4l
.fbuffer
)
271 mem
= fh
->buffers
.buffer
[i
].v4l
.fbuffer
;
272 for (off
= 0; off
< fh
->buffers
.buffer_size
;
274 ClearPageReserved(virt_to_page(mem
+ off
));
275 kfree(fh
->buffers
.buffer
[i
].v4l
.fbuffer
);
276 fh
->buffers
.buffer
[i
].v4l
.fbuffer
= NULL
;
279 fh
->buffers
.allocated
= 0;
283 * Allocate the MJPEG grab buffers.
285 * If a Natoma chipset is present and this is a revision 1 zr36057,
286 * each MJPEG buffer needs to be physically contiguous.
287 * (RJ: This statement is from Dave Perks' original driver,
288 * I could never check it because I have a zr36067)
290 * RJ: The contents grab buffers needs never be accessed in the driver.
291 * Therefore there is no need to allocate them with vmalloc in order
292 * to get a contiguous virtual memory space.
293 * I don't understand why many other drivers first allocate them with
294 * vmalloc (which uses internally also get_zeroed_page, but delivers you
295 * virtual addresses) and then again have to make a lot of efforts
296 * to get the physical address.
299 * On big-endian architectures (such as ppc) some extra steps
300 * are needed. When reading and writing to the stat_com array
301 * and fragment buffers, the device expects to see little-
302 * endian values. The use of cpu_to_le32() and le32_to_cpu()
303 * in this function (and one or two others in zoran_device.c)
304 * ensure that these values are always stored in little-endian
305 * form, regardless of architecture. The zr36057 does Very Bad
306 * Things on big endian architectures if the stat_com array
307 * and fragment buffers are not little-endian.
310 static int jpg_fbuffer_alloc(struct zoran_fh
*fh
)
312 struct zoran
*zr
= fh
->zr
;
316 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
317 if (fh
->buffers
.buffer
[i
].jpg
.frag_tab
)
320 "%s: %s - buffer %d already allocated!?\n",
321 ZR_DEVNAME(zr
), __func__
, i
);
323 /* Allocate fragment table for this buffer */
325 mem
= (void *)get_zeroed_page(GFP_KERNEL
);
329 "%s: %s - get_zeroed_page (frag_tab) failed for buffer %d\n",
330 ZR_DEVNAME(zr
), __func__
, i
);
331 jpg_fbuffer_free(fh
);
334 fh
->buffers
.buffer
[i
].jpg
.frag_tab
= (__le32
*)mem
;
335 fh
->buffers
.buffer
[i
].jpg
.frag_tab_bus
= virt_to_bus(mem
);
337 if (fh
->buffers
.need_contiguous
) {
338 mem
= kmalloc(fh
->buffers
.buffer_size
, GFP_KERNEL
);
342 "%s: %s - kmalloc failed for buffer %d\n",
343 ZR_DEVNAME(zr
), __func__
, i
);
344 jpg_fbuffer_free(fh
);
347 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[0] =
348 cpu_to_le32(virt_to_bus(mem
));
349 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[1] =
350 cpu_to_le32((fh
->buffers
.buffer_size
>> 1) | 1);
351 for (off
= 0; off
< fh
->buffers
.buffer_size
; off
+= PAGE_SIZE
)
352 SetPageReserved(virt_to_page(mem
+ off
));
354 /* jpg_bufsize is already page aligned */
355 for (j
= 0; j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
; j
++) {
356 mem
= (void *)get_zeroed_page(GFP_KERNEL
);
360 "%s: %s - get_zeroed_page failed for buffer %d\n",
361 ZR_DEVNAME(zr
), __func__
, i
);
362 jpg_fbuffer_free(fh
);
366 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
] =
367 cpu_to_le32(virt_to_bus(mem
));
368 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
+ 1] =
369 cpu_to_le32((PAGE_SIZE
>> 2) << 1);
370 SetPageReserved(virt_to_page(mem
));
373 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
- 1] |= cpu_to_le32(1);
378 KERN_DEBUG
"%s: %s - %d KB allocated\n",
379 ZR_DEVNAME(zr
), __func__
,
380 (fh
->buffers
.num_buffers
* fh
->buffers
.buffer_size
) >> 10);
382 fh
->buffers
.allocated
= 1;
387 /* free the MJPEG grab buffers */
388 static void jpg_fbuffer_free(struct zoran_fh
*fh
)
390 struct zoran
*zr
= fh
->zr
;
394 struct zoran_buffer
*buffer
;
396 dprintk(4, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
398 for (i
= 0, buffer
= &fh
->buffers
.buffer
[0];
399 i
< fh
->buffers
.num_buffers
; i
++, buffer
++) {
400 if (!buffer
->jpg
.frag_tab
)
403 if (fh
->buffers
.need_contiguous
) {
404 frag_tab
= buffer
->jpg
.frag_tab
[0];
407 mem
= bus_to_virt(le32_to_cpu(frag_tab
));
408 for (off
= 0; off
< fh
->buffers
.buffer_size
; off
+= PAGE_SIZE
)
409 ClearPageReserved(virt_to_page(mem
+ off
));
411 buffer
->jpg
.frag_tab
[0] = 0;
412 buffer
->jpg
.frag_tab
[1] = 0;
415 for (j
= 0; j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
; j
++) {
416 frag_tab
= buffer
->jpg
.frag_tab
[2 * j
];
420 ClearPageReserved(virt_to_page(bus_to_virt(le32_to_cpu(frag_tab
))));
421 free_page((unsigned long)bus_to_virt(le32_to_cpu(frag_tab
)));
422 buffer
->jpg
.frag_tab
[2 * j
] = 0;
423 buffer
->jpg
.frag_tab
[2 * j
+ 1] = 0;
427 free_page((unsigned long)buffer
->jpg
.frag_tab
);
428 buffer
->jpg
.frag_tab
= NULL
;
431 fh
->buffers
.allocated
= 0;
435 * V4L Buffer grabbing
439 zoran_v4l_set_format (struct zoran_fh
*fh
,
442 const struct zoran_format
*format
)
444 struct zoran
*zr
= fh
->zr
;
447 /* Check size and format of the grab wanted */
449 if (height
< BUZ_MIN_HEIGHT
|| width
< BUZ_MIN_WIDTH
||
450 height
> BUZ_MAX_HEIGHT
|| width
> BUZ_MAX_WIDTH
) {
453 "%s: %s - wrong frame size (%dx%d)\n",
454 ZR_DEVNAME(zr
), __func__
, width
, height
);
458 bpp
= (format
->depth
+ 7) / 8;
460 /* Check against available buffer size */
461 if (height
* width
* bpp
> fh
->buffers
.buffer_size
) {
464 "%s: %s - video buffer size (%d kB) is too small\n",
465 ZR_DEVNAME(zr
), __func__
, fh
->buffers
.buffer_size
>> 10);
469 /* The video front end needs 4-byte alinged line sizes */
471 if ((bpp
== 2 && (width
& 1)) || (bpp
== 3 && (width
& 3))) {
474 "%s: %s - wrong frame alignment\n",
475 ZR_DEVNAME(zr
), __func__
);
479 fh
->v4l_settings
.width
= width
;
480 fh
->v4l_settings
.height
= height
;
481 fh
->v4l_settings
.format
= format
;
482 fh
->v4l_settings
.bytesperline
= bpp
* fh
->v4l_settings
.width
;
487 static int zoran_v4l_queue_frame(struct zoran_fh
*fh
, int num
)
489 struct zoran
*zr
= fh
->zr
;
493 if (!fh
->buffers
.allocated
) {
496 "%s: %s - buffers not yet allocated\n",
497 ZR_DEVNAME(zr
), __func__
);
501 /* No grabbing outside the buffer range! */
502 if (num
>= fh
->buffers
.num_buffers
|| num
< 0) {
505 "%s: %s - buffer %d is out of range\n",
506 ZR_DEVNAME(zr
), __func__
, num
);
510 spin_lock_irqsave(&zr
->spinlock
, flags
);
512 if (fh
->buffers
.active
== ZORAN_FREE
) {
513 if (zr
->v4l_buffers
.active
== ZORAN_FREE
) {
514 zr
->v4l_buffers
= fh
->buffers
;
515 fh
->buffers
.active
= ZORAN_ACTIVE
;
519 "%s: %s - another session is already capturing\n",
520 ZR_DEVNAME(zr
), __func__
);
525 /* make sure a grab isn't going on currently with this buffer */
527 switch (zr
->v4l_buffers
.buffer
[num
].state
) {
530 if (zr
->v4l_buffers
.active
== ZORAN_FREE
) {
531 fh
->buffers
.active
= ZORAN_FREE
;
532 zr
->v4l_buffers
.allocated
= 0;
534 res
= -EBUSY
; /* what are you doing? */
539 "%s: %s - queueing buffer %d in state DONE!?\n",
540 ZR_DEVNAME(zr
), __func__
, num
);
542 /* since there is at least one unused buffer there's room for at least
543 * one more pend[] entry */
544 zr
->v4l_pend
[zr
->v4l_pend_head
++ & V4L_MASK_FRAME
] = num
;
545 zr
->v4l_buffers
.buffer
[num
].state
= BUZ_STATE_PEND
;
546 zr
->v4l_buffers
.buffer
[num
].bs
.length
=
547 fh
->v4l_settings
.bytesperline
*
548 zr
->v4l_settings
.height
;
549 fh
->buffers
.buffer
[num
] = zr
->v4l_buffers
.buffer
[num
];
554 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
556 if (!res
&& zr
->v4l_buffers
.active
== ZORAN_FREE
)
557 zr
->v4l_buffers
.active
= fh
->buffers
.active
;
563 * Sync on a V4L buffer
566 static int v4l_sync(struct zoran_fh
*fh
, int frame
)
568 struct zoran
*zr
= fh
->zr
;
571 if (fh
->buffers
.active
== ZORAN_FREE
) {
574 "%s: %s - no grab active for this session\n",
575 ZR_DEVNAME(zr
), __func__
);
579 /* check passed-in frame number */
580 if (frame
>= fh
->buffers
.num_buffers
|| frame
< 0) {
582 KERN_ERR
"%s: %s - frame %d is invalid\n",
583 ZR_DEVNAME(zr
), __func__
, frame
);
587 /* Check if is buffer was queued at all */
588 if (zr
->v4l_buffers
.buffer
[frame
].state
== BUZ_STATE_USER
) {
591 "%s: %s - attempt to sync on a buffer which was not queued?\n",
592 ZR_DEVNAME(zr
), __func__
);
596 /* wait on this buffer to get ready */
597 if (!wait_event_interruptible_timeout(zr
->v4l_capq
,
598 (zr
->v4l_buffers
.buffer
[frame
].state
!= BUZ_STATE_PEND
), 10*HZ
))
600 if (signal_pending(current
))
603 /* buffer should now be in BUZ_STATE_DONE */
604 if (zr
->v4l_buffers
.buffer
[frame
].state
!= BUZ_STATE_DONE
)
606 KERN_ERR
"%s: %s - internal state error\n",
607 ZR_DEVNAME(zr
), __func__
);
609 zr
->v4l_buffers
.buffer
[frame
].state
= BUZ_STATE_USER
;
610 fh
->buffers
.buffer
[frame
] = zr
->v4l_buffers
.buffer
[frame
];
612 spin_lock_irqsave(&zr
->spinlock
, flags
);
614 /* Check if streaming capture has finished */
615 if (zr
->v4l_pend_tail
== zr
->v4l_pend_head
) {
616 zr36057_set_memgrab(zr
, 0);
617 if (zr
->v4l_buffers
.active
== ZORAN_ACTIVE
) {
618 fh
->buffers
.active
= zr
->v4l_buffers
.active
= ZORAN_FREE
;
619 zr
->v4l_buffers
.allocated
= 0;
623 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
629 * Queue a MJPEG buffer for capture/playback
632 static int zoran_jpg_queue_frame(struct zoran_fh
*fh
, int num
,
633 enum zoran_codec_mode mode
)
635 struct zoran
*zr
= fh
->zr
;
639 /* Check if buffers are allocated */
640 if (!fh
->buffers
.allocated
) {
643 "%s: %s - buffers not yet allocated\n",
644 ZR_DEVNAME(zr
), __func__
);
648 /* No grabbing outside the buffer range! */
649 if (num
>= fh
->buffers
.num_buffers
|| num
< 0) {
652 "%s: %s - buffer %d out of range\n",
653 ZR_DEVNAME(zr
), __func__
, num
);
657 /* what is the codec mode right now? */
658 if (zr
->codec_mode
== BUZ_MODE_IDLE
) {
659 zr
->jpg_settings
= fh
->jpg_settings
;
660 } else if (zr
->codec_mode
!= mode
) {
661 /* wrong codec mode active - invalid */
664 "%s: %s - codec in wrong mode\n",
665 ZR_DEVNAME(zr
), __func__
);
669 if (fh
->buffers
.active
== ZORAN_FREE
) {
670 if (zr
->jpg_buffers
.active
== ZORAN_FREE
) {
671 zr
->jpg_buffers
= fh
->buffers
;
672 fh
->buffers
.active
= ZORAN_ACTIVE
;
676 "%s: %s - another session is already capturing\n",
677 ZR_DEVNAME(zr
), __func__
);
682 if (!res
&& zr
->codec_mode
== BUZ_MODE_IDLE
) {
683 /* Ok load up the jpeg codec */
684 zr36057_enable_jpg(zr
, mode
);
687 spin_lock_irqsave(&zr
->spinlock
, flags
);
690 switch (zr
->jpg_buffers
.buffer
[num
].state
) {
694 "%s: %s - queing frame in BUZ_STATE_DONE state!?\n",
695 ZR_DEVNAME(zr
), __func__
);
697 /* since there is at least one unused buffer there's room for at
698 *least one more pend[] entry */
699 zr
->jpg_pend
[zr
->jpg_que_head
++ & BUZ_MASK_FRAME
] = num
;
700 zr
->jpg_buffers
.buffer
[num
].state
= BUZ_STATE_PEND
;
701 fh
->buffers
.buffer
[num
] = zr
->jpg_buffers
.buffer
[num
];
702 zoran_feed_stat_com(zr
);
707 if (zr
->jpg_buffers
.active
== ZORAN_FREE
) {
708 fh
->buffers
.active
= ZORAN_FREE
;
709 zr
->jpg_buffers
.allocated
= 0;
711 res
= -EBUSY
; /* what are you doing? */
716 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
718 if (!res
&& zr
->jpg_buffers
.active
== ZORAN_FREE
)
719 zr
->jpg_buffers
.active
= fh
->buffers
.active
;
724 static int jpg_qbuf(struct zoran_fh
*fh
, int frame
, enum zoran_codec_mode mode
)
726 struct zoran
*zr
= fh
->zr
;
729 /* Does the user want to stop streaming? */
731 if (zr
->codec_mode
== mode
) {
732 if (fh
->buffers
.active
== ZORAN_FREE
) {
735 "%s: %s(-1) - session not active\n",
736 ZR_DEVNAME(zr
), __func__
);
739 fh
->buffers
.active
= zr
->jpg_buffers
.active
= ZORAN_FREE
;
740 zr
->jpg_buffers
.allocated
= 0;
741 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
746 "%s: %s - stop streaming but not in streaming mode\n",
747 ZR_DEVNAME(zr
), __func__
);
752 if ((res
= zoran_jpg_queue_frame(fh
, frame
, mode
)))
755 /* Start the jpeg codec when the first frame is queued */
756 if (!res
&& zr
->jpg_que_head
== 1)
763 * Sync on a MJPEG buffer
766 static int jpg_sync(struct zoran_fh
*fh
, struct zoran_sync
*bs
)
768 struct zoran
*zr
= fh
->zr
;
772 if (fh
->buffers
.active
== ZORAN_FREE
) {
775 "%s: %s - capture is not currently active\n",
776 ZR_DEVNAME(zr
), __func__
);
779 if (zr
->codec_mode
!= BUZ_MODE_MOTION_DECOMPRESS
&&
780 zr
->codec_mode
!= BUZ_MODE_MOTION_COMPRESS
) {
783 "%s: %s - codec not in streaming mode\n",
784 ZR_DEVNAME(zr
), __func__
);
787 if (!wait_event_interruptible_timeout(zr
->jpg_capq
,
788 (zr
->jpg_que_tail
!= zr
->jpg_dma_tail
||
789 zr
->jpg_dma_tail
== zr
->jpg_dma_head
),
793 btand(~ZR36057_JMC_Go_en
, ZR36057_JMC
);
795 zr
->codec
->control(zr
->codec
, CODEC_G_STATUS
,
799 "%s: %s - timeout: codec isr=0x%02x\n",
800 ZR_DEVNAME(zr
), __func__
, isr
);
805 if (signal_pending(current
))
808 spin_lock_irqsave(&zr
->spinlock
, flags
);
810 if (zr
->jpg_dma_tail
!= zr
->jpg_dma_head
)
811 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
++ & BUZ_MASK_FRAME
];
813 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
815 /* buffer should now be in BUZ_STATE_DONE */
816 if (zr
->jpg_buffers
.buffer
[frame
].state
!= BUZ_STATE_DONE
)
818 KERN_ERR
"%s: %s - internal state error\n",
819 ZR_DEVNAME(zr
), __func__
);
821 *bs
= zr
->jpg_buffers
.buffer
[frame
].bs
;
823 zr
->jpg_buffers
.buffer
[frame
].state
= BUZ_STATE_USER
;
824 fh
->buffers
.buffer
[frame
] = zr
->jpg_buffers
.buffer
[frame
];
826 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
831 static void zoran_open_init_session(struct zoran_fh
*fh
)
834 struct zoran
*zr
= fh
->zr
;
836 /* Per default, map the V4L Buffers */
839 /* take over the card's current settings */
840 fh
->overlay_settings
= zr
->overlay_settings
;
841 fh
->overlay_settings
.is_set
= 0;
842 fh
->overlay_settings
.format
= zr
->overlay_settings
.format
;
843 fh
->overlay_active
= ZORAN_FREE
;
846 fh
->v4l_settings
= zr
->v4l_settings
;
848 fh
->jpg_settings
= zr
->jpg_settings
;
851 memset(&fh
->buffers
, 0, sizeof(fh
->buffers
));
852 for (i
= 0; i
< MAX_FRAME
; i
++) {
853 fh
->buffers
.buffer
[i
].state
= BUZ_STATE_USER
; /* nothing going on */
854 fh
->buffers
.buffer
[i
].bs
.frame
= i
;
856 fh
->buffers
.allocated
= 0;
857 fh
->buffers
.active
= ZORAN_FREE
;
860 static void zoran_close_end_session(struct zoran_fh
*fh
)
862 struct zoran
*zr
= fh
->zr
;
865 if (fh
->overlay_active
!= ZORAN_FREE
) {
866 fh
->overlay_active
= zr
->overlay_active
= ZORAN_FREE
;
867 zr
->v4l_overlay_active
= 0;
868 if (!zr
->v4l_memgrab_active
)
869 zr36057_overlay(zr
, 0);
870 zr
->overlay_mask
= NULL
;
873 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
875 if (fh
->buffers
.active
!= ZORAN_FREE
) {
878 spin_lock_irqsave(&zr
->spinlock
, flags
);
879 zr36057_set_memgrab(zr
, 0);
880 zr
->v4l_buffers
.allocated
= 0;
881 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
882 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
886 if (fh
->buffers
.allocated
)
887 v4l_fbuffer_free(fh
);
890 if (fh
->buffers
.active
!= ZORAN_FREE
) {
891 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
892 zr
->jpg_buffers
.allocated
= 0;
893 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
897 if (fh
->buffers
.allocated
)
898 jpg_fbuffer_free(fh
);
903 * Open a zoran card. Right now the flags stuff is just playing
906 static int zoran_open(struct file
*file
)
908 struct zoran
*zr
= video_drvdata(file
);
910 int res
, first_open
= 0;
912 dprintk(2, KERN_INFO
"%s: %s(%s, pid=[%d]), users(-)=%d\n",
913 ZR_DEVNAME(zr
), __func__
, current
->comm
, task_pid_nr(current
), zr
->user
+ 1);
917 if (zr
->user
>= 2048) {
918 dprintk(1, KERN_ERR
"%s: too many users (%d) on device\n",
919 ZR_DEVNAME(zr
), zr
->user
);
924 /* now, create the open()-specific file_ops struct */
925 fh
= kzalloc(sizeof(struct zoran_fh
), GFP_KERNEL
);
929 "%s: %s - allocation of zoran_fh failed\n",
930 ZR_DEVNAME(zr
), __func__
);
934 /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
937 kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL
);
938 if (!fh
->overlay_mask
) {
941 "%s: %s - allocation of overlay_mask failed\n",
942 ZR_DEVNAME(zr
), __func__
);
950 /*mutex_unlock(&zr->resource_lock);*/
952 /* default setup - TODO: look at flags */
953 if (first_open
) { /* First device open */
955 zoran_open_init_params(zr
);
956 zoran_init_hardware(zr
);
958 btor(ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
961 /* set file_ops stuff */
962 file
->private_data
= fh
;
964 zoran_open_init_session(fh
);
974 dprintk(2, KERN_INFO
"%s: open failed (%d), users(-)=%d\n",
975 ZR_DEVNAME(zr
), res
, zr
->user
);
981 zoran_close(struct file
*file
)
983 struct zoran_fh
*fh
= file
->private_data
;
984 struct zoran
*zr
= fh
->zr
;
986 dprintk(2, KERN_INFO
"%s: %s(%s, pid=[%d]), users(+)=%d\n",
987 ZR_DEVNAME(zr
), __func__
, current
->comm
, task_pid_nr(current
), zr
->user
- 1);
989 /* kernel locks (fs/device.c), so don't do that ourselves
990 * (prevents deadlocks) */
991 /*mutex_lock(&zr->resource_lock);*/
993 zoran_close_end_session(fh
);
995 if (zr
->user
-- == 1) { /* Last process */
996 /* Clean up JPEG process */
997 wake_up_interruptible(&zr
->jpg_capq
);
998 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
999 zr
->jpg_buffers
.allocated
= 0;
1000 zr
->jpg_buffers
.active
= ZORAN_FREE
;
1002 /* disable interrupts */
1003 btand(~ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
1005 if (zr36067_debug
> 1)
1006 print_interrupts(zr
);
1009 zr
->v4l_overlay_active
= 0;
1010 zr36057_overlay(zr
, 0);
1011 zr
->overlay_mask
= NULL
;
1014 wake_up_interruptible(&zr
->v4l_capq
);
1015 zr36057_set_memgrab(zr
, 0);
1016 zr
->v4l_buffers
.allocated
= 0;
1017 zr
->v4l_buffers
.active
= ZORAN_FREE
;
1018 zoran_set_pci_master(zr
, 0);
1020 if (!pass_through
) { /* Switch to color bar */
1021 struct v4l2_routing route
= { 2, 0 };
1023 decoder_call(zr
, video
, s_stream
, 0);
1024 encoder_call(zr
, video
, s_routing
, &route
);
1028 file
->private_data
= NULL
;
1029 kfree(fh
->overlay_mask
);
1032 dprintk(4, KERN_INFO
"%s: %s done\n", ZR_DEVNAME(zr
), __func__
);
1039 zoran_read (struct file
*file
,
1044 /* we simply don't support read() (yet)... */
1050 zoran_write (struct file
*file
,
1051 const char __user
*data
,
1055 /* ...and the same goes for write() */
1060 static int setup_fbuffer(struct zoran_fh
*fh
,
1062 const struct zoran_format
*fmt
,
1067 struct zoran
*zr
= fh
->zr
;
1069 /* (Ronald) v4l/v4l2 guidelines */
1070 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
1073 /* Don't allow frame buffer overlay if PCI or AGP is buggy, or on
1074 ALi Magik (that needs very low latency while the card needs a
1075 higher value always) */
1077 if (pci_pci_problems
& (PCIPCI_FAIL
| PCIAGP_FAIL
| PCIPCI_ALIMAGIK
))
1080 /* we need a bytesperline value, even if not given */
1082 bytesperline
= width
* ((fmt
->depth
+ 7) & ~7) / 8;
1085 if (zr
->overlay_active
) {
1086 /* dzjee... stupid users... don't even bother to turn off
1087 * overlay before changing the memory location...
1088 * normally, we would return errors here. However, one of
1089 * the tools that does this is... xawtv! and since xawtv
1090 * is used by +/- 99% of the users, we'd rather be user-
1091 * friendly and silently do as if nothing went wrong */
1094 "%s: %s - forced overlay turnoff because framebuffer changed\n",
1095 ZR_DEVNAME(zr
), __func__
);
1096 zr36057_overlay(zr
, 0);
1100 if (!(fmt
->flags
& ZORAN_FORMAT_OVERLAY
)) {
1103 "%s: %s - no valid overlay format given\n",
1104 ZR_DEVNAME(zr
), __func__
);
1107 if (height
<= 0 || width
<= 0 || bytesperline
<= 0) {
1110 "%s: %s - invalid height/width/bpl value (%d|%d|%d)\n",
1111 ZR_DEVNAME(zr
), __func__
, width
, height
, bytesperline
);
1114 if (bytesperline
& 3) {
1117 "%s: %s - bytesperline (%d) must be 4-byte aligned\n",
1118 ZR_DEVNAME(zr
), __func__
, bytesperline
);
1122 zr
->vbuf_base
= (void *) ((unsigned long) base
& ~3);
1123 zr
->vbuf_height
= height
;
1124 zr
->vbuf_width
= width
;
1125 zr
->vbuf_depth
= fmt
->depth
;
1126 zr
->overlay_settings
.format
= fmt
;
1127 zr
->vbuf_bytesperline
= bytesperline
;
1129 /* The user should set new window parameters */
1130 zr
->overlay_settings
.is_set
= 0;
1136 static int setup_window(struct zoran_fh
*fh
, int x
, int y
, int width
, int height
,
1137 struct v4l2_clip __user
*clips
, int clipcount
, void __user
*bitmap
)
1139 struct zoran
*zr
= fh
->zr
;
1140 struct v4l2_clip
*vcp
= NULL
;
1144 if (!zr
->vbuf_base
) {
1147 "%s: %s - frame buffer has to be set first\n",
1148 ZR_DEVNAME(zr
), __func__
);
1152 if (!fh
->overlay_settings
.format
) {
1155 "%s: %s - no overlay format set\n",
1156 ZR_DEVNAME(zr
), __func__
);
1161 * The video front end needs 4-byte alinged line sizes, we correct that
1162 * silently here if necessary
1164 if (zr
->vbuf_depth
== 15 || zr
->vbuf_depth
== 16) {
1165 end
= (x
+ width
) & ~1; /* round down */
1166 x
= (x
+ 1) & ~1; /* round up */
1170 if (zr
->vbuf_depth
== 24) {
1171 end
= (x
+ width
) & ~3; /* round down */
1172 x
= (x
+ 3) & ~3; /* round up */
1176 if (width
> BUZ_MAX_WIDTH
)
1177 width
= BUZ_MAX_WIDTH
;
1178 if (height
> BUZ_MAX_HEIGHT
)
1179 height
= BUZ_MAX_HEIGHT
;
1181 /* Check for vaild parameters */
1182 if (width
< BUZ_MIN_WIDTH
|| height
< BUZ_MIN_HEIGHT
||
1183 width
> BUZ_MAX_WIDTH
|| height
> BUZ_MAX_HEIGHT
) {
1186 "%s: %s - width = %d or height = %d invalid\n",
1187 ZR_DEVNAME(zr
), __func__
, width
, height
);
1191 fh
->overlay_settings
.x
= x
;
1192 fh
->overlay_settings
.y
= y
;
1193 fh
->overlay_settings
.width
= width
;
1194 fh
->overlay_settings
.height
= height
;
1195 fh
->overlay_settings
.clipcount
= clipcount
;
1198 * If an overlay is running, we have to switch it off
1199 * and switch it on again in order to get the new settings in effect.
1201 * We also want to avoid that the overlay mask is written
1202 * when an overlay is running.
1205 on
= zr
->v4l_overlay_active
&& !zr
->v4l_memgrab_active
&&
1206 zr
->overlay_active
!= ZORAN_FREE
&&
1207 fh
->overlay_active
!= ZORAN_FREE
;
1209 zr36057_overlay(zr
, 0);
1212 * Write the overlay mask if clips are wanted.
1213 * We prefer a bitmap.
1216 /* fake value - it just means we want clips */
1217 fh
->overlay_settings
.clipcount
= 1;
1219 if (copy_from_user(fh
->overlay_mask
, bitmap
,
1220 (width
* height
+ 7) / 8)) {
1223 } else if (clipcount
> 0) {
1224 /* write our own bitmap from the clips */
1225 vcp
= vmalloc(sizeof(struct v4l2_clip
) * (clipcount
+ 4));
1229 "%s: %s - Alloc of clip mask failed\n",
1230 ZR_DEVNAME(zr
), __func__
);
1234 (vcp
, clips
, sizeof(struct v4l2_clip
) * clipcount
)) {
1238 write_overlay_mask(fh
, vcp
, clipcount
);
1242 fh
->overlay_settings
.is_set
= 1;
1243 if (fh
->overlay_active
!= ZORAN_FREE
&&
1244 zr
->overlay_active
!= ZORAN_FREE
)
1245 zr
->overlay_settings
= fh
->overlay_settings
;
1248 zr36057_overlay(zr
, 1);
1250 /* Make sure the changes come into effect */
1251 return wait_grab_pending(zr
);
1254 static int setup_overlay(struct zoran_fh
*fh
, int on
)
1256 struct zoran
*zr
= fh
->zr
;
1258 /* If there is nothing to do, return immediatly */
1259 if ((on
&& fh
->overlay_active
!= ZORAN_FREE
) ||
1260 (!on
&& fh
->overlay_active
== ZORAN_FREE
))
1263 /* check whether we're touching someone else's overlay */
1264 if (on
&& zr
->overlay_active
!= ZORAN_FREE
&&
1265 fh
->overlay_active
== ZORAN_FREE
) {
1268 "%s: %s - overlay is already active for another session\n",
1269 ZR_DEVNAME(zr
), __func__
);
1272 if (!on
&& zr
->overlay_active
!= ZORAN_FREE
&&
1273 fh
->overlay_active
== ZORAN_FREE
) {
1276 "%s: %s - you cannot cancel someone else's session\n",
1277 ZR_DEVNAME(zr
), __func__
);
1282 zr
->overlay_active
= fh
->overlay_active
= ZORAN_FREE
;
1283 zr
->v4l_overlay_active
= 0;
1284 /* When a grab is running, the video simply
1285 * won't be switched on any more */
1286 if (!zr
->v4l_memgrab_active
)
1287 zr36057_overlay(zr
, 0);
1288 zr
->overlay_mask
= NULL
;
1290 if (!zr
->vbuf_base
|| !fh
->overlay_settings
.is_set
) {
1293 "%s: %s - buffer or window not set\n",
1294 ZR_DEVNAME(zr
), __func__
);
1297 if (!fh
->overlay_settings
.format
) {
1300 "%s: %s - no overlay format set\n",
1301 ZR_DEVNAME(zr
), __func__
);
1304 zr
->overlay_active
= fh
->overlay_active
= ZORAN_LOCKED
;
1305 zr
->v4l_overlay_active
= 1;
1306 zr
->overlay_mask
= fh
->overlay_mask
;
1307 zr
->overlay_settings
= fh
->overlay_settings
;
1308 if (!zr
->v4l_memgrab_active
)
1309 zr36057_overlay(zr
, 1);
1310 /* When a grab is running, the video will be
1311 * switched on when grab is finished */
1314 /* Make sure the changes come into effect */
1315 return wait_grab_pending(zr
);
1318 /* get the status of a buffer in the clients buffer queue */
1319 static int zoran_v4l2_buffer_status(struct zoran_fh
*fh
,
1320 struct v4l2_buffer
*buf
, int num
)
1322 struct zoran
*zr
= fh
->zr
;
1323 unsigned long flags
;
1325 buf
->flags
= V4L2_BUF_FLAG_MAPPED
;
1327 switch (fh
->map_mode
) {
1328 case ZORAN_MAP_MODE_RAW
:
1330 if (num
< 0 || num
>= fh
->buffers
.num_buffers
||
1331 !fh
->buffers
.allocated
) {
1334 "%s: %s - wrong number or buffers not allocated\n",
1335 ZR_DEVNAME(zr
), __func__
);
1339 spin_lock_irqsave(&zr
->spinlock
, flags
);
1342 "%s: %s() - raw active=%c, buffer %d: state=%c, map=%c\n",
1343 ZR_DEVNAME(zr
), __func__
,
1344 "FAL"[fh
->buffers
.active
], num
,
1345 "UPMD"[zr
->v4l_buffers
.buffer
[num
].state
],
1346 fh
->buffers
.buffer
[num
].map
? 'Y' : 'N');
1347 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
1349 buf
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1350 buf
->length
= fh
->buffers
.buffer_size
;
1353 buf
->bytesused
= fh
->buffers
.buffer
[num
].bs
.length
;
1354 if (fh
->buffers
.buffer
[num
].state
== BUZ_STATE_DONE
||
1355 fh
->buffers
.buffer
[num
].state
== BUZ_STATE_USER
) {
1356 buf
->sequence
= fh
->buffers
.buffer
[num
].bs
.seq
;
1357 buf
->flags
|= V4L2_BUF_FLAG_DONE
;
1358 buf
->timestamp
= fh
->buffers
.buffer
[num
].bs
.timestamp
;
1360 buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1363 if (fh
->v4l_settings
.height
<= BUZ_MAX_HEIGHT
/ 2)
1364 buf
->field
= V4L2_FIELD_TOP
;
1366 buf
->field
= V4L2_FIELD_INTERLACED
;
1370 case ZORAN_MAP_MODE_JPG_REC
:
1371 case ZORAN_MAP_MODE_JPG_PLAY
:
1374 if (num
< 0 || num
>= fh
->buffers
.num_buffers
||
1375 !fh
->buffers
.allocated
) {
1378 "%s: %s - wrong number or buffers not allocated\n",
1379 ZR_DEVNAME(zr
), __func__
);
1383 buf
->type
= (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
) ?
1384 V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1385 V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1386 buf
->length
= fh
->buffers
.buffer_size
;
1388 /* these variables are only written after frame has been captured */
1389 if (fh
->buffers
.buffer
[num
].state
== BUZ_STATE_DONE
||
1390 fh
->buffers
.buffer
[num
].state
== BUZ_STATE_USER
) {
1391 buf
->sequence
= fh
->buffers
.buffer
[num
].bs
.seq
;
1392 buf
->timestamp
= fh
->buffers
.buffer
[num
].bs
.timestamp
;
1393 buf
->bytesused
= fh
->buffers
.buffer
[num
].bs
.length
;
1394 buf
->flags
|= V4L2_BUF_FLAG_DONE
;
1396 buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1399 /* which fields are these? */
1400 if (fh
->jpg_settings
.TmpDcm
!= 1)
1401 buf
->field
= fh
->jpg_settings
.odd_even
?
1402 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
;
1404 buf
->field
= fh
->jpg_settings
.odd_even
?
1405 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
;
1413 "%s: %s - invalid buffer type|map_mode (%d|%d)\n",
1414 ZR_DEVNAME(zr
), __func__
, buf
->type
, fh
->map_mode
);
1418 buf
->memory
= V4L2_MEMORY_MMAP
;
1420 buf
->m
.offset
= buf
->length
* num
;
1426 zoran_set_norm (struct zoran
*zr
,
1431 if (zr
->v4l_buffers
.active
!= ZORAN_FREE
||
1432 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
1435 "%s: %s called while in playback/capture mode\n",
1436 ZR_DEVNAME(zr
), __func__
);
1440 if (!(norm
& zr
->card
.norms
)) {
1442 KERN_ERR
"%s: %s - unsupported norm %llx\n",
1443 ZR_DEVNAME(zr
), __func__
, norm
);
1447 if (norm
== V4L2_STD_ALL
) {
1449 v4l2_std_id std
= 0;
1451 decoder_call(zr
, video
, querystd
, &std
);
1452 decoder_call(zr
, tuner
, s_std
, std
);
1454 /* let changes come into effect */
1457 decoder_call(zr
, video
, g_input_status
, &status
);
1458 if (status
& V4L2_IN_ST_NO_SIGNAL
) {
1461 "%s: %s - no norm detected\n",
1462 ZR_DEVNAME(zr
), __func__
);
1464 decoder_call(zr
, tuner
, s_std
, zr
->norm
);
1470 if (norm
& V4L2_STD_SECAM
)
1471 zr
->timing
= zr
->card
.tvn
[2];
1472 else if (norm
& V4L2_STD_NTSC
)
1473 zr
->timing
= zr
->card
.tvn
[1];
1475 zr
->timing
= zr
->card
.tvn
[0];
1477 /* We switch overlay off and on since a change in the
1478 * norm needs different VFE settings */
1479 on
= zr
->overlay_active
&& !zr
->v4l_memgrab_active
;
1481 zr36057_overlay(zr
, 0);
1483 decoder_call(zr
, tuner
, s_std
, norm
);
1484 encoder_call(zr
, video
, s_std_output
, norm
);
1487 zr36057_overlay(zr
, 1);
1489 /* Make sure the changes come into effect */
1496 zoran_set_input (struct zoran
*zr
,
1499 struct v4l2_routing route
= { 0, 0 };
1501 if (input
== zr
->input
) {
1505 if (zr
->v4l_buffers
.active
!= ZORAN_FREE
||
1506 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
1509 "%s: %s called while in playback/capture mode\n",
1510 ZR_DEVNAME(zr
), __func__
);
1514 if (input
< 0 || input
>= zr
->card
.inputs
) {
1517 "%s: %s - unnsupported input %d\n",
1518 ZR_DEVNAME(zr
), __func__
, input
);
1522 route
.input
= zr
->card
.input
[input
].muxsel
;
1525 decoder_call(zr
, video
, s_routing
, &route
);
1534 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1535 static long zoran_default(struct file
*file
, void *__fh
, int cmd
, void *arg
)
1537 struct zoran_fh
*fh
= __fh
;
1538 struct zoran
*zr
= fh
->zr
;
1539 struct zoran_jpg_settings settings
;
1542 case BUZIOC_G_PARAMS
:
1544 struct zoran_params
*bparams
= arg
;
1546 dprintk(3, KERN_DEBUG
"%s: BUZIOC_G_PARAMS\n", ZR_DEVNAME(zr
));
1548 memset(bparams
, 0, sizeof(struct zoran_params
));
1549 bparams
->major_version
= MAJOR_VERSION
;
1550 bparams
->minor_version
= MINOR_VERSION
;
1552 mutex_lock(&zr
->resource_lock
);
1554 if (zr
->norm
& V4L2_STD_NTSC
)
1555 bparams
->norm
= VIDEO_MODE_NTSC
;
1556 else if (zr
->norm
& V4L2_STD_PAL
)
1557 bparams
->norm
= VIDEO_MODE_PAL
;
1559 bparams
->norm
= VIDEO_MODE_SECAM
;
1561 bparams
->input
= zr
->input
;
1563 bparams
->decimation
= fh
->jpg_settings
.decimation
;
1564 bparams
->HorDcm
= fh
->jpg_settings
.HorDcm
;
1565 bparams
->VerDcm
= fh
->jpg_settings
.VerDcm
;
1566 bparams
->TmpDcm
= fh
->jpg_settings
.TmpDcm
;
1567 bparams
->field_per_buff
= fh
->jpg_settings
.field_per_buff
;
1568 bparams
->img_x
= fh
->jpg_settings
.img_x
;
1569 bparams
->img_y
= fh
->jpg_settings
.img_y
;
1570 bparams
->img_width
= fh
->jpg_settings
.img_width
;
1571 bparams
->img_height
= fh
->jpg_settings
.img_height
;
1572 bparams
->odd_even
= fh
->jpg_settings
.odd_even
;
1574 bparams
->quality
= fh
->jpg_settings
.jpg_comp
.quality
;
1575 bparams
->APPn
= fh
->jpg_settings
.jpg_comp
.APPn
;
1576 bparams
->APP_len
= fh
->jpg_settings
.jpg_comp
.APP_len
;
1577 memcpy(bparams
->APP_data
,
1578 fh
->jpg_settings
.jpg_comp
.APP_data
,
1579 sizeof(bparams
->APP_data
));
1580 bparams
->COM_len
= zr
->jpg_settings
.jpg_comp
.COM_len
;
1581 memcpy(bparams
->COM_data
,
1582 fh
->jpg_settings
.jpg_comp
.COM_data
,
1583 sizeof(bparams
->COM_data
));
1584 bparams
->jpeg_markers
=
1585 fh
->jpg_settings
.jpg_comp
.jpeg_markers
;
1587 mutex_unlock(&zr
->resource_lock
);
1589 bparams
->VFIFO_FB
= 0;
1594 case BUZIOC_S_PARAMS
:
1596 struct zoran_params
*bparams
= arg
;
1599 dprintk(3, KERN_DEBUG
"%s: BUZIOC_S_PARAMS\n", ZR_DEVNAME(zr
));
1601 settings
.decimation
= bparams
->decimation
;
1602 settings
.HorDcm
= bparams
->HorDcm
;
1603 settings
.VerDcm
= bparams
->VerDcm
;
1604 settings
.TmpDcm
= bparams
->TmpDcm
;
1605 settings
.field_per_buff
= bparams
->field_per_buff
;
1606 settings
.img_x
= bparams
->img_x
;
1607 settings
.img_y
= bparams
->img_y
;
1608 settings
.img_width
= bparams
->img_width
;
1609 settings
.img_height
= bparams
->img_height
;
1610 settings
.odd_even
= bparams
->odd_even
;
1612 settings
.jpg_comp
.quality
= bparams
->quality
;
1613 settings
.jpg_comp
.APPn
= bparams
->APPn
;
1614 settings
.jpg_comp
.APP_len
= bparams
->APP_len
;
1615 memcpy(settings
.jpg_comp
.APP_data
, bparams
->APP_data
,
1616 sizeof(bparams
->APP_data
));
1617 settings
.jpg_comp
.COM_len
= bparams
->COM_len
;
1618 memcpy(settings
.jpg_comp
.COM_data
, bparams
->COM_data
,
1619 sizeof(bparams
->COM_data
));
1620 settings
.jpg_comp
.jpeg_markers
= bparams
->jpeg_markers
;
1622 mutex_lock(&zr
->resource_lock
);
1624 if (zr
->codec_mode
!= BUZ_MODE_IDLE
) {
1627 "%s: BUZIOC_S_PARAMS called, but Buz in capture/playback mode\n",
1630 goto sparams_unlock_and_return
;
1633 /* Check the params first before overwriting our
1635 if (zoran_check_jpg_settings(zr
, &settings
, 0)) {
1637 goto sparams_unlock_and_return
;
1640 fh
->jpg_settings
= settings
;
1641 sparams_unlock_and_return
:
1642 mutex_unlock(&zr
->resource_lock
);
1647 case BUZIOC_REQBUFS
:
1649 struct zoran_requestbuffers
*breq
= arg
;
1654 "%s: BUZIOC_REQBUFS - count=%lu, size=%lu\n",
1655 ZR_DEVNAME(zr
), breq
->count
, breq
->size
);
1657 /* Enforce reasonable lower and upper limits */
1658 if (breq
->count
< 4)
1659 breq
->count
= 4; /* Could be choosen smaller */
1660 if (breq
->count
> jpg_nbufs
)
1661 breq
->count
= jpg_nbufs
;
1662 breq
->size
= PAGE_ALIGN(breq
->size
);
1663 if (breq
->size
< 8192)
1664 breq
->size
= 8192; /* Arbitrary */
1665 /* breq->size is limited by 1 page for the stat_com
1666 * tables to a Maximum of 2 MB */
1667 if (breq
->size
> jpg_bufsize
)
1668 breq
->size
= jpg_bufsize
;
1670 mutex_lock(&zr
->resource_lock
);
1672 if (fh
->buffers
.allocated
) {
1675 "%s: BUZIOC_REQBUFS - buffers already allocated\n",
1678 goto jpgreqbuf_unlock_and_return
;
1681 /* The next mmap will map the MJPEG buffers - could
1682 * also be *_PLAY, but it doesn't matter here */
1683 map_mode_jpg(fh
, 0);
1684 fh
->buffers
.num_buffers
= breq
->count
;
1685 fh
->buffers
.buffer_size
= breq
->size
;
1687 if (jpg_fbuffer_alloc(fh
)) {
1689 goto jpgreqbuf_unlock_and_return
;
1692 jpgreqbuf_unlock_and_return
:
1693 mutex_unlock(&zr
->resource_lock
);
1698 case BUZIOC_QBUF_CAPT
:
1700 int *frame
= arg
, res
;
1702 dprintk(3, KERN_DEBUG
"%s: BUZIOC_QBUF_CAPT - frame=%d\n",
1703 ZR_DEVNAME(zr
), *frame
);
1705 mutex_lock(&zr
->resource_lock
);
1706 res
= jpg_qbuf(fh
, *frame
, BUZ_MODE_MOTION_COMPRESS
);
1707 mutex_unlock(&zr
->resource_lock
);
1712 case BUZIOC_QBUF_PLAY
:
1714 int *frame
= arg
, res
;
1716 dprintk(3, KERN_DEBUG
"%s: BUZIOC_QBUF_PLAY - frame=%d\n",
1717 ZR_DEVNAME(zr
), *frame
);
1719 mutex_lock(&zr
->resource_lock
);
1720 res
= jpg_qbuf(fh
, *frame
, BUZ_MODE_MOTION_DECOMPRESS
);
1721 mutex_unlock(&zr
->resource_lock
);
1728 struct zoran_sync
*bsync
= arg
;
1731 dprintk(3, KERN_DEBUG
"%s: BUZIOC_SYNC\n", ZR_DEVNAME(zr
));
1733 mutex_lock(&zr
->resource_lock
);
1735 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
1736 dprintk(2, KERN_WARNING
1737 "%s: %s - not in jpg capture mode\n",
1738 ZR_DEVNAME(zr
), __func__
);
1741 res
= jpg_sync(fh
, bsync
);
1743 mutex_unlock(&zr
->resource_lock
);
1748 case BUZIOC_G_STATUS
:
1750 struct zoran_status
*bstat
= arg
;
1751 struct v4l2_routing route
= { 0, 0 };
1752 int status
= 0, res
= 0;
1755 dprintk(3, KERN_DEBUG
"%s: BUZIOC_G_STATUS\n", ZR_DEVNAME(zr
));
1757 if (zr
->codec_mode
!= BUZ_MODE_IDLE
) {
1760 "%s: BUZIOC_G_STATUS called but Buz in capture/playback mode\n",
1765 route
.input
= zr
->card
.input
[bstat
->input
].muxsel
;
1767 mutex_lock(&zr
->resource_lock
);
1769 if (zr
->codec_mode
!= BUZ_MODE_IDLE
) {
1772 "%s: BUZIOC_G_STATUS called, but Buz in capture/playback mode\n",
1775 goto gstat_unlock_and_return
;
1778 decoder_call(zr
, video
, s_routing
, &route
);
1780 /* sleep 1 second */
1783 /* Get status of video decoder */
1784 decoder_call(zr
, video
, querystd
, &norm
);
1785 decoder_call(zr
, video
, g_input_status
, &status
);
1787 /* restore previous input and norm */
1788 route
.input
= zr
->card
.input
[zr
->input
].muxsel
;
1789 decoder_call(zr
, video
, s_routing
, &route
);
1790 gstat_unlock_and_return
:
1791 mutex_unlock(&zr
->resource_lock
);
1795 (status
& V4L2_IN_ST_NO_SIGNAL
) ? 0 : 1;
1796 if (norm
& V4L2_STD_NTSC
)
1797 bstat
->norm
= VIDEO_MODE_NTSC
;
1798 else if (norm
& V4L2_STD_SECAM
)
1799 bstat
->norm
= VIDEO_MODE_SECAM
;
1801 bstat
->norm
= VIDEO_MODE_PAL
;
1804 (status
& V4L2_IN_ST_NO_COLOR
) ? 0 : 1;
1815 static int zoran_vidiocgmbuf(struct file
*file
, void *__fh
, struct video_mbuf
*vmbuf
)
1817 struct zoran_fh
*fh
= __fh
;
1818 struct zoran
*zr
= fh
->zr
;
1822 mutex_lock(&zr
->resource_lock
);
1824 if (fh
->buffers
.allocated
) {
1827 "%s: VIDIOCGMBUF - buffers already allocated\n",
1830 goto v4l1reqbuf_unlock_and_return
;
1833 /* The next mmap will map the V4L buffers */
1836 if (v4l_fbuffer_alloc(fh
)) {
1838 goto v4l1reqbuf_unlock_and_return
;
1841 vmbuf
->size
= fh
->buffers
.num_buffers
* fh
->buffers
.buffer_size
;
1842 vmbuf
->frames
= fh
->buffers
.num_buffers
;
1843 for (i
= 0; i
< vmbuf
->frames
; i
++)
1844 vmbuf
->offsets
[i
] = i
* fh
->buffers
.buffer_size
;
1846 v4l1reqbuf_unlock_and_return
:
1847 mutex_unlock(&zr
->resource_lock
);
1853 static int zoran_querycap(struct file
*file
, void *__fh
, struct v4l2_capability
*cap
)
1855 struct zoran_fh
*fh
= __fh
;
1856 struct zoran
*zr
= fh
->zr
;
1858 memset(cap
, 0, sizeof(*cap
));
1859 strncpy(cap
->card
, ZR_DEVNAME(zr
), sizeof(cap
->card
)-1);
1860 strncpy(cap
->driver
, "zoran", sizeof(cap
->driver
)-1);
1861 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "PCI:%s",
1862 pci_name(zr
->pci_dev
));
1863 cap
->version
= KERNEL_VERSION(MAJOR_VERSION
, MINOR_VERSION
,
1865 cap
->capabilities
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_CAPTURE
|
1866 V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_VIDEO_OVERLAY
;
1870 static int zoran_enum_fmt(struct zoran
*zr
, struct v4l2_fmtdesc
*fmt
, int flag
)
1874 for (i
= 0; i
< NUM_FORMATS
; i
++) {
1875 if (zoran_formats
[i
].flags
& flag
)
1877 if (num
== fmt
->index
)
1880 if (fmt
->index
< 0 /* late, but not too late */ || i
== NUM_FORMATS
)
1883 strncpy(fmt
->description
, zoran_formats
[i
].name
, sizeof(fmt
->description
)-1);
1884 fmt
->pixelformat
= zoran_formats
[i
].fourcc
;
1885 if (zoran_formats
[i
].flags
& ZORAN_FORMAT_COMPRESSED
)
1886 fmt
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
1890 static int zoran_enum_fmt_vid_cap(struct file
*file
, void *__fh
,
1891 struct v4l2_fmtdesc
*f
)
1893 struct zoran_fh
*fh
= __fh
;
1894 struct zoran
*zr
= fh
->zr
;
1896 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_CAPTURE
);
1899 static int zoran_enum_fmt_vid_out(struct file
*file
, void *__fh
,
1900 struct v4l2_fmtdesc
*f
)
1902 struct zoran_fh
*fh
= __fh
;
1903 struct zoran
*zr
= fh
->zr
;
1905 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_PLAYBACK
);
1908 static int zoran_enum_fmt_vid_overlay(struct file
*file
, void *__fh
,
1909 struct v4l2_fmtdesc
*f
)
1911 struct zoran_fh
*fh
= __fh
;
1912 struct zoran
*zr
= fh
->zr
;
1914 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_OVERLAY
);
1917 static int zoran_g_fmt_vid_out(struct file
*file
, void *__fh
,
1918 struct v4l2_format
*fmt
)
1920 struct zoran_fh
*fh
= __fh
;
1921 struct zoran
*zr
= fh
->zr
;
1923 mutex_lock(&zr
->resource_lock
);
1925 fmt
->fmt
.pix
.width
= fh
->jpg_settings
.img_width
/ fh
->jpg_settings
.HorDcm
;
1926 fmt
->fmt
.pix
.height
= fh
->jpg_settings
.img_height
* 2 /
1927 (fh
->jpg_settings
.VerDcm
* fh
->jpg_settings
.TmpDcm
);
1928 fmt
->fmt
.pix
.sizeimage
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
1929 fmt
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_MJPEG
;
1930 if (fh
->jpg_settings
.TmpDcm
== 1)
1931 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1932 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1934 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1935 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1936 fmt
->fmt
.pix
.bytesperline
= 0;
1937 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1939 mutex_unlock(&zr
->resource_lock
);
1943 static int zoran_g_fmt_vid_cap(struct file
*file
, void *__fh
,
1944 struct v4l2_format
*fmt
)
1946 struct zoran_fh
*fh
= __fh
;
1947 struct zoran
*zr
= fh
->zr
;
1949 if (fh
->map_mode
!= ZORAN_MAP_MODE_RAW
)
1950 return zoran_g_fmt_vid_out(file
, fh
, fmt
);
1952 mutex_lock(&zr
->resource_lock
);
1953 fmt
->fmt
.pix
.width
= fh
->v4l_settings
.width
;
1954 fmt
->fmt
.pix
.height
= fh
->v4l_settings
.height
;
1955 fmt
->fmt
.pix
.sizeimage
= fh
->v4l_settings
.bytesperline
*
1956 fh
->v4l_settings
.height
;
1957 fmt
->fmt
.pix
.pixelformat
= fh
->v4l_settings
.format
->fourcc
;
1958 fmt
->fmt
.pix
.colorspace
= fh
->v4l_settings
.format
->colorspace
;
1959 fmt
->fmt
.pix
.bytesperline
= fh
->v4l_settings
.bytesperline
;
1960 if (BUZ_MAX_HEIGHT
< (fh
->v4l_settings
.height
* 2))
1961 fmt
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1963 fmt
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
1964 mutex_unlock(&zr
->resource_lock
);
1968 static int zoran_g_fmt_vid_overlay(struct file
*file
, void *__fh
,
1969 struct v4l2_format
*fmt
)
1971 struct zoran_fh
*fh
= __fh
;
1972 struct zoran
*zr
= fh
->zr
;
1974 mutex_lock(&zr
->resource_lock
);
1976 fmt
->fmt
.win
.w
.left
= fh
->overlay_settings
.x
;
1977 fmt
->fmt
.win
.w
.top
= fh
->overlay_settings
.y
;
1978 fmt
->fmt
.win
.w
.width
= fh
->overlay_settings
.width
;
1979 fmt
->fmt
.win
.w
.height
= fh
->overlay_settings
.height
;
1980 if (fh
->overlay_settings
.width
* 2 > BUZ_MAX_HEIGHT
)
1981 fmt
->fmt
.win
.field
= V4L2_FIELD_INTERLACED
;
1983 fmt
->fmt
.win
.field
= V4L2_FIELD_TOP
;
1985 mutex_unlock(&zr
->resource_lock
);
1989 static int zoran_try_fmt_vid_overlay(struct file
*file
, void *__fh
,
1990 struct v4l2_format
*fmt
)
1992 struct zoran_fh
*fh
= __fh
;
1993 struct zoran
*zr
= fh
->zr
;
1995 mutex_lock(&zr
->resource_lock
);
1997 if (fmt
->fmt
.win
.w
.width
> BUZ_MAX_WIDTH
)
1998 fmt
->fmt
.win
.w
.width
= BUZ_MAX_WIDTH
;
1999 if (fmt
->fmt
.win
.w
.width
< BUZ_MIN_WIDTH
)
2000 fmt
->fmt
.win
.w
.width
= BUZ_MIN_WIDTH
;
2001 if (fmt
->fmt
.win
.w
.height
> BUZ_MAX_HEIGHT
)
2002 fmt
->fmt
.win
.w
.height
= BUZ_MAX_HEIGHT
;
2003 if (fmt
->fmt
.win
.w
.height
< BUZ_MIN_HEIGHT
)
2004 fmt
->fmt
.win
.w
.height
= BUZ_MIN_HEIGHT
;
2006 mutex_unlock(&zr
->resource_lock
);
2010 static int zoran_try_fmt_vid_out(struct file
*file
, void *__fh
,
2011 struct v4l2_format
*fmt
)
2013 struct zoran_fh
*fh
= __fh
;
2014 struct zoran
*zr
= fh
->zr
;
2015 struct zoran_jpg_settings settings
;
2018 if (fmt
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
2021 mutex_lock(&zr
->resource_lock
);
2022 settings
= fh
->jpg_settings
;
2024 /* we actually need to set 'real' parameters now */
2025 if ((fmt
->fmt
.pix
.height
* 2) > BUZ_MAX_HEIGHT
)
2026 settings
.TmpDcm
= 1;
2028 settings
.TmpDcm
= 2;
2029 settings
.decimation
= 0;
2030 if (fmt
->fmt
.pix
.height
<= fh
->jpg_settings
.img_height
/ 2)
2031 settings
.VerDcm
= 2;
2033 settings
.VerDcm
= 1;
2034 if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 4)
2035 settings
.HorDcm
= 4;
2036 else if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 2)
2037 settings
.HorDcm
= 2;
2039 settings
.HorDcm
= 1;
2040 if (settings
.TmpDcm
== 1)
2041 settings
.field_per_buff
= 2;
2043 settings
.field_per_buff
= 1;
2045 if (settings
.HorDcm
> 1) {
2046 settings
.img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
2047 settings
.img_width
= (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
2050 settings
.img_width
= BUZ_MAX_WIDTH
;
2054 res
= zoran_check_jpg_settings(zr
, &settings
, 1);
2056 goto tryfmt_unlock_and_return
;
2058 /* tell the user what we actually did */
2059 fmt
->fmt
.pix
.width
= settings
.img_width
/ settings
.HorDcm
;
2060 fmt
->fmt
.pix
.height
= settings
.img_height
* 2 /
2061 (settings
.TmpDcm
* settings
.VerDcm
);
2062 if (settings
.TmpDcm
== 1)
2063 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
2064 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
2066 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
2067 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
2069 fmt
->fmt
.pix
.sizeimage
= zoran_v4l2_calc_bufsize(&settings
);
2070 fmt
->fmt
.pix
.bytesperline
= 0;
2071 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
2072 tryfmt_unlock_and_return
:
2073 mutex_unlock(&zr
->resource_lock
);
2077 static int zoran_try_fmt_vid_cap(struct file
*file
, void *__fh
,
2078 struct v4l2_format
*fmt
)
2080 struct zoran_fh
*fh
= __fh
;
2081 struct zoran
*zr
= fh
->zr
;
2085 if (fmt
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_MJPEG
)
2086 return zoran_try_fmt_vid_out(file
, fh
, fmt
);
2088 mutex_lock(&zr
->resource_lock
);
2090 for (i
= 0; i
< NUM_FORMATS
; i
++)
2091 if (zoran_formats
[i
].fourcc
== fmt
->fmt
.pix
.pixelformat
)
2094 if (i
== NUM_FORMATS
) {
2095 mutex_unlock(&zr
->resource_lock
);
2099 bpp
= (zoran_formats
[i
].depth
+ 7) / 8;
2100 fmt
->fmt
.pix
.width
&= ~((bpp
== 2) ? 1 : 3);
2101 if (fmt
->fmt
.pix
.width
> BUZ_MAX_WIDTH
)
2102 fmt
->fmt
.pix
.width
= BUZ_MAX_WIDTH
;
2103 if (fmt
->fmt
.pix
.width
< BUZ_MIN_WIDTH
)
2104 fmt
->fmt
.pix
.width
= BUZ_MIN_WIDTH
;
2105 if (fmt
->fmt
.pix
.height
> BUZ_MAX_HEIGHT
)
2106 fmt
->fmt
.pix
.height
= BUZ_MAX_HEIGHT
;
2107 if (fmt
->fmt
.pix
.height
< BUZ_MIN_HEIGHT
)
2108 fmt
->fmt
.pix
.height
= BUZ_MIN_HEIGHT
;
2109 mutex_unlock(&zr
->resource_lock
);
2114 static int zoran_s_fmt_vid_overlay(struct file
*file
, void *__fh
,
2115 struct v4l2_format
*fmt
)
2117 struct zoran_fh
*fh
= __fh
;
2118 struct zoran
*zr
= fh
->zr
;
2121 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
2122 fmt
->fmt
.win
.w
.left
, fmt
->fmt
.win
.w
.top
,
2123 fmt
->fmt
.win
.w
.width
,
2124 fmt
->fmt
.win
.w
.height
,
2125 fmt
->fmt
.win
.clipcount
,
2126 fmt
->fmt
.win
.bitmap
);
2127 mutex_lock(&zr
->resource_lock
);
2128 res
= setup_window(fh
, fmt
->fmt
.win
.w
.left
, fmt
->fmt
.win
.w
.top
,
2129 fmt
->fmt
.win
.w
.width
, fmt
->fmt
.win
.w
.height
,
2130 (struct v4l2_clip __user
*)fmt
->fmt
.win
.clips
,
2131 fmt
->fmt
.win
.clipcount
, fmt
->fmt
.win
.bitmap
);
2132 mutex_unlock(&zr
->resource_lock
);
2136 static int zoran_s_fmt_vid_out(struct file
*file
, void *__fh
,
2137 struct v4l2_format
*fmt
)
2139 struct zoran_fh
*fh
= __fh
;
2140 struct zoran
*zr
= fh
->zr
;
2141 __le32 printformat
= __cpu_to_le32(fmt
->fmt
.pix
.pixelformat
);
2142 struct zoran_jpg_settings settings
;
2145 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
2146 fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
,
2147 fmt
->fmt
.pix
.pixelformat
,
2148 (char *) &printformat
);
2149 if (fmt
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
2152 mutex_lock(&zr
->resource_lock
);
2154 if (fh
->buffers
.allocated
) {
2155 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - cannot change capture mode\n",
2158 goto sfmtjpg_unlock_and_return
;
2161 settings
= fh
->jpg_settings
;
2163 /* we actually need to set 'real' parameters now */
2164 if (fmt
->fmt
.pix
.height
* 2 > BUZ_MAX_HEIGHT
)
2165 settings
.TmpDcm
= 1;
2167 settings
.TmpDcm
= 2;
2168 settings
.decimation
= 0;
2169 if (fmt
->fmt
.pix
.height
<= fh
->jpg_settings
.img_height
/ 2)
2170 settings
.VerDcm
= 2;
2172 settings
.VerDcm
= 1;
2173 if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 4)
2174 settings
.HorDcm
= 4;
2175 else if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 2)
2176 settings
.HorDcm
= 2;
2178 settings
.HorDcm
= 1;
2179 if (settings
.TmpDcm
== 1)
2180 settings
.field_per_buff
= 2;
2182 settings
.field_per_buff
= 1;
2184 if (settings
.HorDcm
> 1) {
2185 settings
.img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
2186 settings
.img_width
= (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
2189 settings
.img_width
= BUZ_MAX_WIDTH
;
2193 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
2195 goto sfmtjpg_unlock_and_return
;
2197 /* it's ok, so set them */
2198 fh
->jpg_settings
= settings
;
2200 map_mode_jpg(fh
, fmt
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
);
2201 fh
->buffers
.buffer_size
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
2203 /* tell the user what we actually did */
2204 fmt
->fmt
.pix
.width
= settings
.img_width
/ settings
.HorDcm
;
2205 fmt
->fmt
.pix
.height
= settings
.img_height
* 2 /
2206 (settings
.TmpDcm
* settings
.VerDcm
);
2207 if (settings
.TmpDcm
== 1)
2208 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
2209 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
2211 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
2212 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
2213 fmt
->fmt
.pix
.bytesperline
= 0;
2214 fmt
->fmt
.pix
.sizeimage
= fh
->buffers
.buffer_size
;
2215 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
2217 sfmtjpg_unlock_and_return
:
2218 mutex_unlock(&zr
->resource_lock
);
2222 static int zoran_s_fmt_vid_cap(struct file
*file
, void *__fh
,
2223 struct v4l2_format
*fmt
)
2225 struct zoran_fh
*fh
= __fh
;
2226 struct zoran
*zr
= fh
->zr
;
2230 if (fmt
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_MJPEG
)
2231 return zoran_s_fmt_vid_out(file
, fh
, fmt
);
2233 for (i
= 0; i
< NUM_FORMATS
; i
++)
2234 if (fmt
->fmt
.pix
.pixelformat
== zoran_formats
[i
].fourcc
)
2236 if (i
== NUM_FORMATS
) {
2237 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",
2238 ZR_DEVNAME(zr
), fmt
->fmt
.pix
.pixelformat
);
2242 mutex_lock(&zr
->resource_lock
);
2244 if ((fh
->map_mode
!= ZORAN_MAP_MODE_RAW
&& fh
->buffers
.allocated
) ||
2245 fh
->buffers
.active
!= ZORAN_FREE
) {
2246 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - cannot change capture mode\n",
2249 goto sfmtv4l_unlock_and_return
;
2251 if (fmt
->fmt
.pix
.height
> BUZ_MAX_HEIGHT
)
2252 fmt
->fmt
.pix
.height
= BUZ_MAX_HEIGHT
;
2253 if (fmt
->fmt
.pix
.width
> BUZ_MAX_WIDTH
)
2254 fmt
->fmt
.pix
.width
= BUZ_MAX_WIDTH
;
2258 res
= zoran_v4l_set_format(fh
, fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
,
2261 goto sfmtv4l_unlock_and_return
;
2263 /* tell the user the results/missing stuff */
2264 fmt
->fmt
.pix
.bytesperline
= fh
->v4l_settings
.bytesperline
;
2265 fmt
->fmt
.pix
.sizeimage
= fh
->v4l_settings
.height
* fh
->v4l_settings
.bytesperline
;
2266 fmt
->fmt
.pix
.colorspace
= fh
->v4l_settings
.format
->colorspace
;
2267 if (BUZ_MAX_HEIGHT
< (fh
->v4l_settings
.height
* 2))
2268 fmt
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
2270 fmt
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
2272 sfmtv4l_unlock_and_return
:
2273 mutex_unlock(&zr
->resource_lock
);
2277 static int zoran_g_fbuf(struct file
*file
, void *__fh
,
2278 struct v4l2_framebuffer
*fb
)
2280 struct zoran_fh
*fh
= __fh
;
2281 struct zoran
*zr
= fh
->zr
;
2283 memset(fb
, 0, sizeof(*fb
));
2284 mutex_lock(&zr
->resource_lock
);
2285 fb
->base
= zr
->vbuf_base
;
2286 fb
->fmt
.width
= zr
->vbuf_width
;
2287 fb
->fmt
.height
= zr
->vbuf_height
;
2288 if (zr
->overlay_settings
.format
)
2289 fb
->fmt
.pixelformat
= fh
->overlay_settings
.format
->fourcc
;
2290 fb
->fmt
.bytesperline
= zr
->vbuf_bytesperline
;
2291 mutex_unlock(&zr
->resource_lock
);
2292 fb
->fmt
.colorspace
= V4L2_COLORSPACE_SRGB
;
2293 fb
->fmt
.field
= V4L2_FIELD_INTERLACED
;
2294 fb
->flags
= V4L2_FBUF_FLAG_OVERLAY
;
2295 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
2300 static int zoran_s_fbuf(struct file
*file
, void *__fh
,
2301 struct v4l2_framebuffer
*fb
)
2303 struct zoran_fh
*fh
= __fh
;
2304 struct zoran
*zr
= fh
->zr
;
2306 __le32 printformat
= __cpu_to_le32(fb
->fmt
.pixelformat
);
2308 for (i
= 0; i
< NUM_FORMATS
; i
++)
2309 if (zoran_formats
[i
].fourcc
== fb
->fmt
.pixelformat
)
2311 if (i
== NUM_FORMATS
) {
2312 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
2313 ZR_DEVNAME(zr
), fb
->fmt
.pixelformat
,
2314 (char *)&printformat
);
2318 mutex_lock(&zr
->resource_lock
);
2319 res
= setup_fbuffer(fh
, fb
->base
, &zoran_formats
[i
], fb
->fmt
.width
,
2320 fb
->fmt
.height
, fb
->fmt
.bytesperline
);
2321 mutex_unlock(&zr
->resource_lock
);
2326 static int zoran_overlay(struct file
*file
, void *__fh
, unsigned int on
)
2328 struct zoran_fh
*fh
= __fh
;
2329 struct zoran
*zr
= fh
->zr
;
2332 mutex_lock(&zr
->resource_lock
);
2333 res
= setup_overlay(fh
, on
);
2334 mutex_unlock(&zr
->resource_lock
);
2339 static int zoran_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
);
2341 static int zoran_reqbufs(struct file
*file
, void *__fh
, struct v4l2_requestbuffers
*req
)
2343 struct zoran_fh
*fh
= __fh
;
2344 struct zoran
*zr
= fh
->zr
;
2347 if (req
->memory
!= V4L2_MEMORY_MMAP
) {
2350 "%s: only MEMORY_MMAP capture is supported, not %d\n",
2351 ZR_DEVNAME(zr
), req
->memory
);
2355 if (req
->count
== 0)
2356 return zoran_streamoff(file
, fh
, req
->type
);
2358 mutex_lock(&zr
->resource_lock
);
2359 if (fh
->buffers
.allocated
) {
2362 "%s: VIDIOC_REQBUFS - buffers already allocated\n",
2365 goto v4l2reqbuf_unlock_and_return
;
2368 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
&&
2369 req
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2370 /* control user input */
2373 if (req
->count
> v4l_nbufs
)
2374 req
->count
= v4l_nbufs
;
2376 /* The next mmap will map the V4L buffers */
2378 fh
->buffers
.num_buffers
= req
->count
;
2380 if (v4l_fbuffer_alloc(fh
)) {
2382 goto v4l2reqbuf_unlock_and_return
;
2384 } else if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
||
2385 fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
) {
2386 /* we need to calculate size ourselves now */
2389 if (req
->count
> jpg_nbufs
)
2390 req
->count
= jpg_nbufs
;
2392 /* The next mmap will map the MJPEG buffers */
2393 map_mode_jpg(fh
, req
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
);
2394 fh
->buffers
.num_buffers
= req
->count
;
2395 fh
->buffers
.buffer_size
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
2397 if (jpg_fbuffer_alloc(fh
)) {
2399 goto v4l2reqbuf_unlock_and_return
;
2404 "%s: VIDIOC_REQBUFS - unknown type %d\n",
2405 ZR_DEVNAME(zr
), req
->type
);
2407 goto v4l2reqbuf_unlock_and_return
;
2409 v4l2reqbuf_unlock_and_return
:
2410 mutex_unlock(&zr
->resource_lock
);
2415 static int zoran_querybuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2417 struct zoran_fh
*fh
= __fh
;
2418 struct zoran
*zr
= fh
->zr
;
2421 mutex_lock(&zr
->resource_lock
);
2422 res
= zoran_v4l2_buffer_status(fh
, buf
, buf
->index
);
2423 mutex_unlock(&zr
->resource_lock
);
2428 static int zoran_qbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2430 struct zoran_fh
*fh
= __fh
;
2431 struct zoran
*zr
= fh
->zr
;
2432 int res
= 0, codec_mode
, buf_type
;
2434 mutex_lock(&zr
->resource_lock
);
2436 switch (fh
->map_mode
) {
2437 case ZORAN_MAP_MODE_RAW
:
2438 if (buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2440 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2441 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2443 goto qbuf_unlock_and_return
;
2446 res
= zoran_v4l_queue_frame(fh
, buf
->index
);
2448 goto qbuf_unlock_and_return
;
2449 if (!zr
->v4l_memgrab_active
&& fh
->buffers
.active
== ZORAN_LOCKED
)
2450 zr36057_set_memgrab(zr
, 1);
2453 case ZORAN_MAP_MODE_JPG_REC
:
2454 case ZORAN_MAP_MODE_JPG_PLAY
:
2455 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
) {
2456 buf_type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2457 codec_mode
= BUZ_MODE_MOTION_DECOMPRESS
;
2459 buf_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2460 codec_mode
= BUZ_MODE_MOTION_COMPRESS
;
2463 if (buf
->type
!= buf_type
) {
2465 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2466 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2468 goto qbuf_unlock_and_return
;
2471 res
= zoran_jpg_queue_frame(fh
, buf
->index
, codec_mode
);
2473 goto qbuf_unlock_and_return
;
2474 if (zr
->codec_mode
== BUZ_MODE_IDLE
&&
2475 fh
->buffers
.active
== ZORAN_LOCKED
)
2476 zr36057_enable_jpg(zr
, codec_mode
);
2482 "%s: VIDIOC_QBUF - unsupported type %d\n",
2483 ZR_DEVNAME(zr
), buf
->type
);
2487 qbuf_unlock_and_return
:
2488 mutex_unlock(&zr
->resource_lock
);
2493 static int zoran_dqbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2495 struct zoran_fh
*fh
= __fh
;
2496 struct zoran
*zr
= fh
->zr
;
2497 int res
= 0, buf_type
, num
= -1; /* compiler borks here (?) */
2499 mutex_lock(&zr
->resource_lock
);
2501 switch (fh
->map_mode
) {
2502 case ZORAN_MAP_MODE_RAW
:
2503 if (buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2505 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2506 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2508 goto dqbuf_unlock_and_return
;
2511 num
= zr
->v4l_pend
[zr
->v4l_sync_tail
& V4L_MASK_FRAME
];
2512 if (file
->f_flags
& O_NONBLOCK
&&
2513 zr
->v4l_buffers
.buffer
[num
].state
!= BUZ_STATE_DONE
) {
2515 goto dqbuf_unlock_and_return
;
2517 res
= v4l_sync(fh
, num
);
2519 goto dqbuf_unlock_and_return
;
2520 zr
->v4l_sync_tail
++;
2521 res
= zoran_v4l2_buffer_status(fh
, buf
, num
);
2524 case ZORAN_MAP_MODE_JPG_REC
:
2525 case ZORAN_MAP_MODE_JPG_PLAY
:
2527 struct zoran_sync bs
;
2529 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
)
2530 buf_type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2532 buf_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2534 if (buf
->type
!= buf_type
) {
2536 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2537 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2539 goto dqbuf_unlock_and_return
;
2542 num
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
2544 if (file
->f_flags
& O_NONBLOCK
&&
2545 zr
->jpg_buffers
.buffer
[num
].state
!= BUZ_STATE_DONE
) {
2547 goto dqbuf_unlock_and_return
;
2549 res
= jpg_sync(fh
, &bs
);
2551 goto dqbuf_unlock_and_return
;
2552 res
= zoran_v4l2_buffer_status(fh
, buf
, bs
.frame
);
2558 "%s: VIDIOC_DQBUF - unsupported type %d\n",
2559 ZR_DEVNAME(zr
), buf
->type
);
2563 dqbuf_unlock_and_return
:
2564 mutex_unlock(&zr
->resource_lock
);
2569 static int zoran_streamon(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
2571 struct zoran_fh
*fh
= __fh
;
2572 struct zoran
*zr
= fh
->zr
;
2575 mutex_lock(&zr
->resource_lock
);
2577 switch (fh
->map_mode
) {
2578 case ZORAN_MAP_MODE_RAW
: /* raw capture */
2579 if (zr
->v4l_buffers
.active
!= ZORAN_ACTIVE
||
2580 fh
->buffers
.active
!= ZORAN_ACTIVE
) {
2582 goto strmon_unlock_and_return
;
2585 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_LOCKED
;
2586 zr
->v4l_settings
= fh
->v4l_settings
;
2588 zr
->v4l_sync_tail
= zr
->v4l_pend_tail
;
2589 if (!zr
->v4l_memgrab_active
&&
2590 zr
->v4l_pend_head
!= zr
->v4l_pend_tail
) {
2591 zr36057_set_memgrab(zr
, 1);
2595 case ZORAN_MAP_MODE_JPG_REC
:
2596 case ZORAN_MAP_MODE_JPG_PLAY
:
2597 /* what is the codec mode right now? */
2598 if (zr
->jpg_buffers
.active
!= ZORAN_ACTIVE
||
2599 fh
->buffers
.active
!= ZORAN_ACTIVE
) {
2601 goto strmon_unlock_and_return
;
2604 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_LOCKED
;
2606 if (zr
->jpg_que_head
!= zr
->jpg_que_tail
) {
2607 /* Start the jpeg codec when the first frame is queued */
2615 "%s: VIDIOC_STREAMON - invalid map mode %d\n",
2616 ZR_DEVNAME(zr
), fh
->map_mode
);
2620 strmon_unlock_and_return
:
2621 mutex_unlock(&zr
->resource_lock
);
2626 static int zoran_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
2628 struct zoran_fh
*fh
= __fh
;
2629 struct zoran
*zr
= fh
->zr
;
2631 unsigned long flags
;
2633 mutex_lock(&zr
->resource_lock
);
2635 switch (fh
->map_mode
) {
2636 case ZORAN_MAP_MODE_RAW
: /* raw capture */
2637 if (fh
->buffers
.active
== ZORAN_FREE
&&
2638 zr
->v4l_buffers
.active
!= ZORAN_FREE
) {
2639 res
= -EPERM
; /* stay off other's settings! */
2640 goto strmoff_unlock_and_return
;
2642 if (zr
->v4l_buffers
.active
== ZORAN_FREE
)
2643 goto strmoff_unlock_and_return
;
2645 spin_lock_irqsave(&zr
->spinlock
, flags
);
2646 /* unload capture */
2647 if (zr
->v4l_memgrab_active
) {
2649 zr36057_set_memgrab(zr
, 0);
2652 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++)
2653 zr
->v4l_buffers
.buffer
[i
].state
= BUZ_STATE_USER
;
2654 fh
->buffers
= zr
->v4l_buffers
;
2656 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2658 zr
->v4l_grab_seq
= 0;
2659 zr
->v4l_pend_head
= zr
->v4l_pend_tail
= 0;
2660 zr
->v4l_sync_tail
= 0;
2662 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2666 case ZORAN_MAP_MODE_JPG_REC
:
2667 case ZORAN_MAP_MODE_JPG_PLAY
:
2668 if (fh
->buffers
.active
== ZORAN_FREE
&&
2669 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
2670 res
= -EPERM
; /* stay off other's settings! */
2671 goto strmoff_unlock_and_return
;
2673 if (zr
->jpg_buffers
.active
== ZORAN_FREE
)
2674 goto strmoff_unlock_and_return
;
2676 res
= jpg_qbuf(fh
, -1,
2677 (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
) ?
2678 BUZ_MODE_MOTION_COMPRESS
:
2679 BUZ_MODE_MOTION_DECOMPRESS
);
2681 goto strmoff_unlock_and_return
;
2685 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
2686 ZR_DEVNAME(zr
), fh
->map_mode
);
2690 strmoff_unlock_and_return
:
2691 mutex_unlock(&zr
->resource_lock
);
2696 static int zoran_queryctrl(struct file
*file
, void *__fh
,
2697 struct v4l2_queryctrl
*ctrl
)
2699 struct zoran_fh
*fh
= __fh
;
2700 struct zoran
*zr
= fh
->zr
;
2702 /* we only support hue/saturation/contrast/brightness */
2703 if (ctrl
->id
< V4L2_CID_BRIGHTNESS
||
2704 ctrl
->id
> V4L2_CID_HUE
)
2707 decoder_call(zr
, core
, queryctrl
, ctrl
);
2712 static int zoran_g_ctrl(struct file
*file
, void *__fh
, struct v4l2_control
*ctrl
)
2714 struct zoran_fh
*fh
= __fh
;
2715 struct zoran
*zr
= fh
->zr
;
2717 /* we only support hue/saturation/contrast/brightness */
2718 if (ctrl
->id
< V4L2_CID_BRIGHTNESS
||
2719 ctrl
->id
> V4L2_CID_HUE
)
2722 mutex_lock(&zr
->resource_lock
);
2723 decoder_call(zr
, core
, g_ctrl
, ctrl
);
2724 mutex_unlock(&zr
->resource_lock
);
2729 static int zoran_s_ctrl(struct file
*file
, void *__fh
, struct v4l2_control
*ctrl
)
2731 struct zoran_fh
*fh
= __fh
;
2732 struct zoran
*zr
= fh
->zr
;
2734 /* we only support hue/saturation/contrast/brightness */
2735 if (ctrl
->id
< V4L2_CID_BRIGHTNESS
||
2736 ctrl
->id
> V4L2_CID_HUE
)
2739 mutex_lock(&zr
->resource_lock
);
2740 decoder_call(zr
, core
, s_ctrl
, ctrl
);
2741 mutex_unlock(&zr
->resource_lock
);
2746 static int zoran_g_std(struct file
*file
, void *__fh
, v4l2_std_id
*std
)
2748 struct zoran_fh
*fh
= __fh
;
2749 struct zoran
*zr
= fh
->zr
;
2751 mutex_lock(&zr
->resource_lock
);
2753 mutex_unlock(&zr
->resource_lock
);
2757 static int zoran_s_std(struct file
*file
, void *__fh
, v4l2_std_id
*std
)
2759 struct zoran_fh
*fh
= __fh
;
2760 struct zoran
*zr
= fh
->zr
;
2763 mutex_lock(&zr
->resource_lock
);
2764 res
= zoran_set_norm(zr
, *std
);
2766 goto sstd_unlock_and_return
;
2768 res
= wait_grab_pending(zr
);
2769 sstd_unlock_and_return
:
2770 mutex_unlock(&zr
->resource_lock
);
2774 static int zoran_enum_input(struct file
*file
, void *__fh
,
2775 struct v4l2_input
*inp
)
2777 struct zoran_fh
*fh
= __fh
;
2778 struct zoran
*zr
= fh
->zr
;
2780 if (inp
->index
< 0 || inp
->index
>= zr
->card
.inputs
)
2783 int id
= inp
->index
;
2784 memset(inp
, 0, sizeof(*inp
));
2788 strncpy(inp
->name
, zr
->card
.input
[inp
->index
].name
,
2789 sizeof(inp
->name
) - 1);
2790 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
2791 inp
->std
= V4L2_STD_ALL
;
2793 /* Get status of video decoder */
2794 mutex_lock(&zr
->resource_lock
);
2795 decoder_call(zr
, video
, g_input_status
, &inp
->status
);
2796 mutex_unlock(&zr
->resource_lock
);
2800 static int zoran_g_input(struct file
*file
, void *__fh
, unsigned int *input
)
2802 struct zoran_fh
*fh
= __fh
;
2803 struct zoran
*zr
= fh
->zr
;
2805 mutex_lock(&zr
->resource_lock
);
2807 mutex_unlock(&zr
->resource_lock
);
2812 static int zoran_s_input(struct file
*file
, void *__fh
, unsigned int input
)
2814 struct zoran_fh
*fh
= __fh
;
2815 struct zoran
*zr
= fh
->zr
;
2818 mutex_lock(&zr
->resource_lock
);
2819 res
= zoran_set_input(zr
, input
);
2821 goto sinput_unlock_and_return
;
2823 /* Make sure the changes come into effect */
2824 res
= wait_grab_pending(zr
);
2825 sinput_unlock_and_return
:
2826 mutex_unlock(&zr
->resource_lock
);
2830 static int zoran_enum_output(struct file
*file
, void *__fh
,
2831 struct v4l2_output
*outp
)
2833 if (outp
->index
!= 0)
2836 memset(outp
, 0, sizeof(*outp
));
2838 outp
->type
= V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY
;
2839 strncpy(outp
->name
, "Autodetect", sizeof(outp
->name
)-1);
2844 static int zoran_g_output(struct file
*file
, void *__fh
, unsigned int *output
)
2851 static int zoran_s_output(struct file
*file
, void *__fh
, unsigned int output
)
2859 /* cropping (sub-frame capture) */
2860 static int zoran_cropcap(struct file
*file
, void *__fh
,
2861 struct v4l2_cropcap
*cropcap
)
2863 struct zoran_fh
*fh
= __fh
;
2864 struct zoran
*zr
= fh
->zr
;
2865 int type
= cropcap
->type
, res
= 0;
2867 memset(cropcap
, 0, sizeof(*cropcap
));
2868 cropcap
->type
= type
;
2870 mutex_lock(&zr
->resource_lock
);
2872 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2873 (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2874 fh
->map_mode
== ZORAN_MAP_MODE_RAW
)) {
2876 "%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",
2879 goto cropcap_unlock_and_return
;
2882 cropcap
->bounds
.top
= cropcap
->bounds
.left
= 0;
2883 cropcap
->bounds
.width
= BUZ_MAX_WIDTH
;
2884 cropcap
->bounds
.height
= BUZ_MAX_HEIGHT
;
2885 cropcap
->defrect
.top
= cropcap
->defrect
.left
= 0;
2886 cropcap
->defrect
.width
= BUZ_MIN_WIDTH
;
2887 cropcap
->defrect
.height
= BUZ_MIN_HEIGHT
;
2888 cropcap_unlock_and_return
:
2889 mutex_unlock(&zr
->resource_lock
);
2893 static int zoran_g_crop(struct file
*file
, void *__fh
, struct v4l2_crop
*crop
)
2895 struct zoran_fh
*fh
= __fh
;
2896 struct zoran
*zr
= fh
->zr
;
2897 int type
= crop
->type
, res
= 0;
2899 memset(crop
, 0, sizeof(*crop
));
2902 mutex_lock(&zr
->resource_lock
);
2904 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2905 (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2906 fh
->map_mode
== ZORAN_MAP_MODE_RAW
)) {
2909 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2912 goto gcrop_unlock_and_return
;
2915 crop
->c
.top
= fh
->jpg_settings
.img_y
;
2916 crop
->c
.left
= fh
->jpg_settings
.img_x
;
2917 crop
->c
.width
= fh
->jpg_settings
.img_width
;
2918 crop
->c
.height
= fh
->jpg_settings
.img_height
;
2920 gcrop_unlock_and_return
:
2921 mutex_unlock(&zr
->resource_lock
);
2926 static int zoran_s_crop(struct file
*file
, void *__fh
, struct v4l2_crop
*crop
)
2928 struct zoran_fh
*fh
= __fh
;
2929 struct zoran
*zr
= fh
->zr
;
2931 struct zoran_jpg_settings settings
;
2933 settings
= fh
->jpg_settings
;
2935 mutex_lock(&zr
->resource_lock
);
2937 if (fh
->buffers
.allocated
) {
2939 "%s: VIDIOC_S_CROP - cannot change settings while active\n",
2942 goto scrop_unlock_and_return
;
2945 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2946 (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2947 fh
->map_mode
== ZORAN_MAP_MODE_RAW
)) {
2949 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2952 goto scrop_unlock_and_return
;
2955 /* move into a form that we understand */
2956 settings
.img_x
= crop
->c
.left
;
2957 settings
.img_y
= crop
->c
.top
;
2958 settings
.img_width
= crop
->c
.width
;
2959 settings
.img_height
= crop
->c
.height
;
2961 /* check validity */
2962 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
2964 goto scrop_unlock_and_return
;
2967 fh
->jpg_settings
= settings
;
2969 scrop_unlock_and_return
:
2970 mutex_unlock(&zr
->resource_lock
);
2974 static int zoran_g_jpegcomp(struct file
*file
, void *__fh
,
2975 struct v4l2_jpegcompression
*params
)
2977 struct zoran_fh
*fh
= __fh
;
2978 struct zoran
*zr
= fh
->zr
;
2979 memset(params
, 0, sizeof(*params
));
2981 mutex_lock(&zr
->resource_lock
);
2983 params
->quality
= fh
->jpg_settings
.jpg_comp
.quality
;
2984 params
->APPn
= fh
->jpg_settings
.jpg_comp
.APPn
;
2985 memcpy(params
->APP_data
,
2986 fh
->jpg_settings
.jpg_comp
.APP_data
,
2987 fh
->jpg_settings
.jpg_comp
.APP_len
);
2988 params
->APP_len
= fh
->jpg_settings
.jpg_comp
.APP_len
;
2989 memcpy(params
->COM_data
,
2990 fh
->jpg_settings
.jpg_comp
.COM_data
,
2991 fh
->jpg_settings
.jpg_comp
.COM_len
);
2992 params
->COM_len
= fh
->jpg_settings
.jpg_comp
.COM_len
;
2993 params
->jpeg_markers
=
2994 fh
->jpg_settings
.jpg_comp
.jpeg_markers
;
2996 mutex_unlock(&zr
->resource_lock
);
3001 static int zoran_s_jpegcomp(struct file
*file
, void *__fh
,
3002 struct v4l2_jpegcompression
*params
)
3004 struct zoran_fh
*fh
= __fh
;
3005 struct zoran
*zr
= fh
->zr
;
3007 struct zoran_jpg_settings settings
;
3009 settings
= fh
->jpg_settings
;
3011 settings
.jpg_comp
= *params
;
3013 mutex_lock(&zr
->resource_lock
);
3015 if (fh
->buffers
.active
!= ZORAN_FREE
) {
3016 dprintk(1, KERN_WARNING
3017 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
3020 goto sjpegc_unlock_and_return
;
3023 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
3025 goto sjpegc_unlock_and_return
;
3026 if (!fh
->buffers
.allocated
)
3027 fh
->buffers
.buffer_size
=
3028 zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
3029 fh
->jpg_settings
.jpg_comp
= *params
= settings
.jpg_comp
;
3030 sjpegc_unlock_and_return
:
3031 mutex_unlock(&zr
->resource_lock
);
3037 zoran_poll (struct file
*file
,
3040 struct zoran_fh
*fh
= file
->private_data
;
3041 struct zoran
*zr
= fh
->zr
;
3043 unsigned long flags
;
3045 /* we should check whether buffers are ready to be synced on
3046 * (w/o waits - O_NONBLOCK) here
3047 * if ready for read (sync), return POLLIN|POLLRDNORM,
3048 * if ready for write (sync), return POLLOUT|POLLWRNORM,
3049 * if error, return POLLERR,
3050 * if no buffers queued or so, return POLLNVAL
3053 mutex_lock(&zr
->resource_lock
);
3055 switch (fh
->map_mode
) {
3056 case ZORAN_MAP_MODE_RAW
:
3057 poll_wait(file
, &zr
->v4l_capq
, wait
);
3058 frame
= zr
->v4l_pend
[zr
->v4l_sync_tail
& V4L_MASK_FRAME
];
3060 spin_lock_irqsave(&zr
->spinlock
, flags
);
3063 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
3064 ZR_DEVNAME(zr
), __func__
,
3065 "FAL"[fh
->buffers
.active
], zr
->v4l_sync_tail
,
3066 "UPMD"[zr
->v4l_buffers
.buffer
[frame
].state
],
3067 zr
->v4l_pend_tail
, zr
->v4l_pend_head
);
3068 /* Process is the one capturing? */
3069 if (fh
->buffers
.active
!= ZORAN_FREE
&&
3070 /* Buffer ready to DQBUF? */
3071 zr
->v4l_buffers
.buffer
[frame
].state
== BUZ_STATE_DONE
)
3072 res
= POLLIN
| POLLRDNORM
;
3073 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
3077 case ZORAN_MAP_MODE_JPG_REC
:
3078 case ZORAN_MAP_MODE_JPG_PLAY
:
3079 poll_wait(file
, &zr
->jpg_capq
, wait
);
3080 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
3082 spin_lock_irqsave(&zr
->spinlock
, flags
);
3085 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
3086 ZR_DEVNAME(zr
), __func__
,
3087 "FAL"[fh
->buffers
.active
], zr
->jpg_que_tail
,
3088 "UPMD"[zr
->jpg_buffers
.buffer
[frame
].state
],
3089 zr
->jpg_que_head
, zr
->jpg_dma_tail
, zr
->jpg_dma_head
);
3090 if (fh
->buffers
.active
!= ZORAN_FREE
&&
3091 zr
->jpg_buffers
.buffer
[frame
].state
== BUZ_STATE_DONE
) {
3092 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
)
3093 res
= POLLIN
| POLLRDNORM
;
3095 res
= POLLOUT
| POLLWRNORM
;
3097 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
3104 "%s: %s - internal error, unknown map_mode=%d\n",
3105 ZR_DEVNAME(zr
), __func__
, fh
->map_mode
);
3109 mutex_unlock(&zr
->resource_lock
);
3116 * This maps the buffers to user space.
3118 * Depending on the state of fh->map_mode
3119 * the V4L or the MJPEG buffers are mapped
3120 * per buffer or all together
3122 * Note that we need to connect to some
3123 * unmap signal event to unmap the de-allocate
3124 * the buffer accordingly (zoran_vm_close())
3128 zoran_vm_open (struct vm_area_struct
*vma
)
3130 struct zoran_mapping
*map
= vma
->vm_private_data
;
3136 zoran_vm_close (struct vm_area_struct
*vma
)
3138 struct zoran_mapping
*map
= vma
->vm_private_data
;
3139 struct zoran_fh
*fh
= map
->file
->private_data
;
3140 struct zoran
*zr
= fh
->zr
;
3143 if (--map
->count
> 0)
3146 dprintk(3, KERN_INFO
"%s: %s - munmap(%s)\n", ZR_DEVNAME(zr
),
3147 __func__
, mode_name(fh
->map_mode
));
3149 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
3150 if (fh
->buffers
.buffer
[i
].map
== map
)
3151 fh
->buffers
.buffer
[i
].map
= NULL
;
3155 /* Any buffers still mapped? */
3156 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++)
3157 if (fh
->buffers
.buffer
[i
].map
)
3160 dprintk(3, KERN_INFO
"%s: %s - free %s buffers\n", ZR_DEVNAME(zr
),
3161 __func__
, mode_name(fh
->map_mode
));
3163 mutex_lock(&zr
->resource_lock
);
3165 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
3166 if (fh
->buffers
.active
!= ZORAN_FREE
) {
3167 unsigned long flags
;
3169 spin_lock_irqsave(&zr
->spinlock
, flags
);
3170 zr36057_set_memgrab(zr
, 0);
3171 zr
->v4l_buffers
.allocated
= 0;
3172 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
3173 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
3175 v4l_fbuffer_free(fh
);
3177 if (fh
->buffers
.active
!= ZORAN_FREE
) {
3178 jpg_qbuf(fh
, -1, zr
->codec_mode
);
3179 zr
->jpg_buffers
.allocated
= 0;
3180 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
3182 jpg_fbuffer_free(fh
);
3185 mutex_unlock(&zr
->resource_lock
);
3188 static struct vm_operations_struct zoran_vm_ops
= {
3189 .open
= zoran_vm_open
,
3190 .close
= zoran_vm_close
,
3194 zoran_mmap (struct file
*file
,
3195 struct vm_area_struct
*vma
)
3197 struct zoran_fh
*fh
= file
->private_data
;
3198 struct zoran
*zr
= fh
->zr
;
3199 unsigned long size
= (vma
->vm_end
- vma
->vm_start
);
3200 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
3202 unsigned long page
, start
= vma
->vm_start
, todo
, pos
, fraglen
;
3204 struct zoran_mapping
*map
;
3208 KERN_INFO
"%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
3209 ZR_DEVNAME(zr
), __func__
,
3210 mode_name(fh
->map_mode
), vma
->vm_start
, vma
->vm_end
, size
);
3212 if (!(vma
->vm_flags
& VM_SHARED
) || !(vma
->vm_flags
& VM_READ
) ||
3213 !(vma
->vm_flags
& VM_WRITE
)) {
3216 "%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n",
3217 ZR_DEVNAME(zr
), __func__
);
3221 mutex_lock(&zr
->resource_lock
);
3223 if (!fh
->buffers
.allocated
) {
3226 "%s: %s(%s) - buffers not yet allocated\n",
3227 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
));
3229 goto mmap_unlock_and_return
;
3232 first
= offset
/ fh
->buffers
.buffer_size
;
3233 last
= first
- 1 + size
/ fh
->buffers
.buffer_size
;
3234 if (offset
% fh
->buffers
.buffer_size
!= 0 ||
3235 size
% fh
->buffers
.buffer_size
!= 0 || first
< 0 ||
3236 last
< 0 || first
>= fh
->buffers
.num_buffers
||
3237 last
>= fh
->buffers
.buffer_size
) {
3240 "%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
3241 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
), offset
, size
,
3242 fh
->buffers
.buffer_size
,
3243 fh
->buffers
.num_buffers
);
3245 goto mmap_unlock_and_return
;
3248 /* Check if any buffers are already mapped */
3249 for (i
= first
; i
<= last
; i
++) {
3250 if (fh
->buffers
.buffer
[i
].map
) {
3253 "%s: %s(%s) - buffer %d already mapped\n",
3254 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
), i
);
3256 goto mmap_unlock_and_return
;
3260 /* map these buffers */
3261 map
= kmalloc(sizeof(struct zoran_mapping
), GFP_KERNEL
);
3264 goto mmap_unlock_and_return
;
3269 vma
->vm_ops
= &zoran_vm_ops
;
3270 vma
->vm_flags
|= VM_DONTEXPAND
;
3271 vma
->vm_private_data
= map
;
3273 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
3274 for (i
= first
; i
<= last
; i
++) {
3276 if (todo
> fh
->buffers
.buffer_size
)
3277 todo
= fh
->buffers
.buffer_size
;
3278 page
= fh
->buffers
.buffer
[i
].v4l
.fbuffer_phys
;
3279 if (remap_pfn_range(vma
, start
, page
>> PAGE_SHIFT
,
3280 todo
, PAGE_SHARED
)) {
3283 "%s: %s(V4L) - remap_pfn_range failed\n",
3284 ZR_DEVNAME(zr
), __func__
);
3286 goto mmap_unlock_and_return
;
3290 fh
->buffers
.buffer
[i
].map
= map
;
3295 for (i
= first
; i
<= last
; i
++) {
3297 j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
;
3300 (le32_to_cpu(fh
->buffers
.buffer
[i
].jpg
.
3301 frag_tab
[2 * j
+ 1]) & ~1) << 1;
3306 le32_to_cpu(fh
->buffers
.
3307 buffer
[i
].jpg
.frag_tab
[2 * j
]);
3308 /* should just be pos on i386 */
3309 page
= virt_to_phys(bus_to_virt(pos
))
3311 if (remap_pfn_range(vma
, start
, page
,
3312 todo
, PAGE_SHARED
)) {
3315 "%s: %s(V4L) - remap_pfn_range failed\n",
3316 ZR_DEVNAME(zr
), __func__
);
3318 goto mmap_unlock_and_return
;
3324 if (le32_to_cpu(fh
->buffers
.buffer
[i
].jpg
.
3325 frag_tab
[2 * j
+ 1]) & 1)
3326 break; /* was last fragment */
3328 fh
->buffers
.buffer
[i
].map
= map
;
3335 mmap_unlock_and_return
:
3336 mutex_unlock(&zr
->resource_lock
);
3341 static const struct v4l2_ioctl_ops zoran_ioctl_ops
= {
3342 .vidioc_querycap
= zoran_querycap
,
3343 .vidioc_cropcap
= zoran_cropcap
,
3344 .vidioc_s_crop
= zoran_s_crop
,
3345 .vidioc_g_crop
= zoran_g_crop
,
3346 .vidioc_enum_input
= zoran_enum_input
,
3347 .vidioc_g_input
= zoran_g_input
,
3348 .vidioc_s_input
= zoran_s_input
,
3349 .vidioc_enum_output
= zoran_enum_output
,
3350 .vidioc_g_output
= zoran_g_output
,
3351 .vidioc_s_output
= zoran_s_output
,
3352 .vidioc_g_fbuf
= zoran_g_fbuf
,
3353 .vidioc_s_fbuf
= zoran_s_fbuf
,
3354 .vidioc_g_std
= zoran_g_std
,
3355 .vidioc_s_std
= zoran_s_std
,
3356 .vidioc_g_jpegcomp
= zoran_g_jpegcomp
,
3357 .vidioc_s_jpegcomp
= zoran_s_jpegcomp
,
3358 .vidioc_overlay
= zoran_overlay
,
3359 .vidioc_reqbufs
= zoran_reqbufs
,
3360 .vidioc_querybuf
= zoran_querybuf
,
3361 .vidioc_qbuf
= zoran_qbuf
,
3362 .vidioc_dqbuf
= zoran_dqbuf
,
3363 .vidioc_streamon
= zoran_streamon
,
3364 .vidioc_streamoff
= zoran_streamoff
,
3365 .vidioc_enum_fmt_vid_cap
= zoran_enum_fmt_vid_cap
,
3366 .vidioc_enum_fmt_vid_out
= zoran_enum_fmt_vid_out
,
3367 .vidioc_enum_fmt_vid_overlay
= zoran_enum_fmt_vid_overlay
,
3368 .vidioc_g_fmt_vid_cap
= zoran_g_fmt_vid_cap
,
3369 .vidioc_g_fmt_vid_out
= zoran_g_fmt_vid_out
,
3370 .vidioc_g_fmt_vid_overlay
= zoran_g_fmt_vid_overlay
,
3371 .vidioc_s_fmt_vid_cap
= zoran_s_fmt_vid_cap
,
3372 .vidioc_s_fmt_vid_out
= zoran_s_fmt_vid_out
,
3373 .vidioc_s_fmt_vid_overlay
= zoran_s_fmt_vid_overlay
,
3374 .vidioc_try_fmt_vid_cap
= zoran_try_fmt_vid_cap
,
3375 .vidioc_try_fmt_vid_out
= zoran_try_fmt_vid_out
,
3376 .vidioc_try_fmt_vid_overlay
= zoran_try_fmt_vid_overlay
,
3377 .vidioc_queryctrl
= zoran_queryctrl
,
3378 .vidioc_s_ctrl
= zoran_s_ctrl
,
3379 .vidioc_g_ctrl
= zoran_g_ctrl
,
3380 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3381 .vidioc_default
= zoran_default
,
3382 .vidiocgmbuf
= zoran_vidiocgmbuf
,
3386 static const struct v4l2_file_operations zoran_fops
= {
3387 .owner
= THIS_MODULE
,
3389 .release
= zoran_close
,
3390 .ioctl
= video_ioctl2
,
3392 .write
= zoran_write
,
3397 struct video_device zoran_template __devinitdata
= {
3399 .fops
= &zoran_fops
,
3400 .ioctl_ops
= &zoran_ioctl_ops
,
3401 .release
= &zoran_vdev_release
,
3402 .tvnorms
= V4L2_STD_NTSC
| V4L2_STD_PAL
| V4L2_STD_SECAM
,