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/init.h>
48 #include <linux/module.h>
49 #include <linux/delay.h>
50 #include <linux/slab.h>
51 #include <linux/pci.h>
52 #include <linux/vmalloc.h>
53 #include <linux/wait.h>
55 #include <linux/interrupt.h>
56 #include <linux/i2c.h>
57 #include <linux/i2c-algo-bit.h>
59 #include <linux/spinlock.h>
61 #include <linux/videodev2.h>
62 #include <media/v4l2-common.h>
63 #include <media/v4l2-ioctl.h>
64 #include "videocodec.h"
66 #include <asm/byteorder.h>
68 #include <asm/uaccess.h>
69 #include <linux/proc_fs.h>
71 #include <linux/mutex.h>
73 #include "zoran_device.h"
74 #include "zoran_card.h"
77 const struct zoran_format zoran_formats
[] = {
79 .name
= "15-bit RGB LE",
80 .fourcc
= V4L2_PIX_FMT_RGB555
,
81 .colorspace
= V4L2_COLORSPACE_SRGB
,
83 .flags
= ZORAN_FORMAT_CAPTURE
|
85 .vfespfr
= ZR36057_VFESPFR_RGB555
|ZR36057_VFESPFR_ErrDif
|
86 ZR36057_VFESPFR_LittleEndian
,
88 .name
= "15-bit RGB BE",
89 .fourcc
= V4L2_PIX_FMT_RGB555X
,
90 .colorspace
= V4L2_COLORSPACE_SRGB
,
92 .flags
= ZORAN_FORMAT_CAPTURE
|
94 .vfespfr
= ZR36057_VFESPFR_RGB555
|ZR36057_VFESPFR_ErrDif
,
96 .name
= "16-bit RGB LE",
97 .fourcc
= V4L2_PIX_FMT_RGB565
,
98 .colorspace
= V4L2_COLORSPACE_SRGB
,
100 .flags
= ZORAN_FORMAT_CAPTURE
|
101 ZORAN_FORMAT_OVERLAY
,
102 .vfespfr
= ZR36057_VFESPFR_RGB565
|ZR36057_VFESPFR_ErrDif
|
103 ZR36057_VFESPFR_LittleEndian
,
105 .name
= "16-bit RGB BE",
106 .fourcc
= V4L2_PIX_FMT_RGB565X
,
107 .colorspace
= V4L2_COLORSPACE_SRGB
,
109 .flags
= ZORAN_FORMAT_CAPTURE
|
110 ZORAN_FORMAT_OVERLAY
,
111 .vfespfr
= ZR36057_VFESPFR_RGB565
|ZR36057_VFESPFR_ErrDif
,
113 .name
= "24-bit RGB",
114 .fourcc
= V4L2_PIX_FMT_BGR24
,
115 .colorspace
= V4L2_COLORSPACE_SRGB
,
117 .flags
= ZORAN_FORMAT_CAPTURE
|
118 ZORAN_FORMAT_OVERLAY
,
119 .vfespfr
= ZR36057_VFESPFR_RGB888
|ZR36057_VFESPFR_Pack24
,
121 .name
= "32-bit RGB LE",
122 .fourcc
= V4L2_PIX_FMT_BGR32
,
123 .colorspace
= V4L2_COLORSPACE_SRGB
,
125 .flags
= ZORAN_FORMAT_CAPTURE
|
126 ZORAN_FORMAT_OVERLAY
,
127 .vfespfr
= ZR36057_VFESPFR_RGB888
|ZR36057_VFESPFR_LittleEndian
,
129 .name
= "32-bit RGB BE",
130 .fourcc
= V4L2_PIX_FMT_RGB32
,
131 .colorspace
= V4L2_COLORSPACE_SRGB
,
133 .flags
= ZORAN_FORMAT_CAPTURE
|
134 ZORAN_FORMAT_OVERLAY
,
135 .vfespfr
= ZR36057_VFESPFR_RGB888
,
137 .name
= "4:2:2, packed, YUYV",
138 .fourcc
= V4L2_PIX_FMT_YUYV
,
139 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
141 .flags
= ZORAN_FORMAT_CAPTURE
|
142 ZORAN_FORMAT_OVERLAY
,
143 .vfespfr
= ZR36057_VFESPFR_YUV422
,
145 .name
= "4:2:2, packed, UYVY",
146 .fourcc
= V4L2_PIX_FMT_UYVY
,
147 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
149 .flags
= ZORAN_FORMAT_CAPTURE
|
150 ZORAN_FORMAT_OVERLAY
,
151 .vfespfr
= ZR36057_VFESPFR_YUV422
|ZR36057_VFESPFR_LittleEndian
,
153 .name
= "Hardware-encoded Motion-JPEG",
154 .fourcc
= V4L2_PIX_FMT_MJPEG
,
155 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
157 .flags
= ZORAN_FORMAT_CAPTURE
|
158 ZORAN_FORMAT_PLAYBACK
|
159 ZORAN_FORMAT_COMPRESSED
,
162 #define NUM_FORMATS ARRAY_SIZE(zoran_formats)
164 /* small helper function for calculating buffersizes for v4l2
165 * we calculate the nearest higher power-of-two, which
166 * will be the recommended buffersize */
168 zoran_v4l2_calc_bufsize (struct zoran_jpg_settings
*settings
)
170 __u8 div
= settings
->VerDcm
* settings
->HorDcm
* settings
->TmpDcm
;
171 __u32 num
= (1024 * 512) / (div
);
180 if (result
> jpg_bufsize
)
187 /* forward references */
188 static void v4l_fbuffer_free(struct zoran_fh
*fh
);
189 static void jpg_fbuffer_free(struct zoran_fh
*fh
);
191 /* Set mapping mode */
192 static void map_mode_raw(struct zoran_fh
*fh
)
194 fh
->map_mode
= ZORAN_MAP_MODE_RAW
;
195 fh
->buffers
.buffer_size
= v4l_bufsize
;
196 fh
->buffers
.num_buffers
= v4l_nbufs
;
198 static void map_mode_jpg(struct zoran_fh
*fh
, int play
)
200 fh
->map_mode
= play
? ZORAN_MAP_MODE_JPG_PLAY
: ZORAN_MAP_MODE_JPG_REC
;
201 fh
->buffers
.buffer_size
= jpg_bufsize
;
202 fh
->buffers
.num_buffers
= jpg_nbufs
;
204 static inline const char *mode_name(enum zoran_map_mode mode
)
206 return mode
== ZORAN_MAP_MODE_RAW
? "V4L" : "JPG";
210 * Allocate the V4L grab buffers
212 * These have to be pysically contiguous.
215 static int v4l_fbuffer_alloc(struct zoran_fh
*fh
)
217 struct zoran
*zr
= fh
->zr
;
221 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
222 if (fh
->buffers
.buffer
[i
].v4l
.fbuffer
)
225 "%s: %s - buffer %d already allocated!?\n",
226 ZR_DEVNAME(zr
), __func__
, i
);
229 mem
= kmalloc(fh
->buffers
.buffer_size
,
230 GFP_KERNEL
| __GFP_NOWARN
);
234 "%s: %s - kmalloc for V4L buf %d failed\n",
235 ZR_DEVNAME(zr
), __func__
, i
);
236 v4l_fbuffer_free(fh
);
239 fh
->buffers
.buffer
[i
].v4l
.fbuffer
= mem
;
240 fh
->buffers
.buffer
[i
].v4l
.fbuffer_phys
= virt_to_phys(mem
);
241 fh
->buffers
.buffer
[i
].v4l
.fbuffer_bus
= virt_to_bus(mem
);
242 for (off
= 0; off
< fh
->buffers
.buffer_size
;
244 SetPageReserved(virt_to_page(mem
+ off
));
247 "%s: %s - V4L frame %d mem 0x%lx (bus: 0x%llx)\n",
248 ZR_DEVNAME(zr
), __func__
, i
, (unsigned long) mem
,
249 (unsigned long long)virt_to_bus(mem
));
252 fh
->buffers
.allocated
= 1;
257 /* free the V4L grab buffers */
258 static void v4l_fbuffer_free(struct zoran_fh
*fh
)
260 struct zoran
*zr
= fh
->zr
;
264 dprintk(4, KERN_INFO
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
266 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
267 if (!fh
->buffers
.buffer
[i
].v4l
.fbuffer
)
270 mem
= fh
->buffers
.buffer
[i
].v4l
.fbuffer
;
271 for (off
= 0; off
< fh
->buffers
.buffer_size
;
273 ClearPageReserved(virt_to_page(mem
+ off
));
274 kfree(fh
->buffers
.buffer
[i
].v4l
.fbuffer
);
275 fh
->buffers
.buffer
[i
].v4l
.fbuffer
= NULL
;
278 fh
->buffers
.allocated
= 0;
282 * Allocate the MJPEG grab buffers.
284 * If a Natoma chipset is present and this is a revision 1 zr36057,
285 * each MJPEG buffer needs to be physically contiguous.
286 * (RJ: This statement is from Dave Perks' original driver,
287 * I could never check it because I have a zr36067)
289 * RJ: The contents grab buffers needs never be accessed in the driver.
290 * Therefore there is no need to allocate them with vmalloc in order
291 * to get a contiguous virtual memory space.
292 * I don't understand why many other drivers first allocate them with
293 * vmalloc (which uses internally also get_zeroed_page, but delivers you
294 * virtual addresses) and then again have to make a lot of efforts
295 * to get the physical address.
298 * On big-endian architectures (such as ppc) some extra steps
299 * are needed. When reading and writing to the stat_com array
300 * and fragment buffers, the device expects to see little-
301 * endian values. The use of cpu_to_le32() and le32_to_cpu()
302 * in this function (and one or two others in zoran_device.c)
303 * ensure that these values are always stored in little-endian
304 * form, regardless of architecture. The zr36057 does Very Bad
305 * Things on big endian architectures if the stat_com array
306 * and fragment buffers are not little-endian.
309 static int jpg_fbuffer_alloc(struct zoran_fh
*fh
)
311 struct zoran
*zr
= fh
->zr
;
315 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
316 if (fh
->buffers
.buffer
[i
].jpg
.frag_tab
)
319 "%s: %s - buffer %d already allocated!?\n",
320 ZR_DEVNAME(zr
), __func__
, i
);
322 /* Allocate fragment table for this buffer */
324 mem
= (void *)get_zeroed_page(GFP_KERNEL
);
328 "%s: %s - get_zeroed_page (frag_tab) failed for buffer %d\n",
329 ZR_DEVNAME(zr
), __func__
, i
);
330 jpg_fbuffer_free(fh
);
333 fh
->buffers
.buffer
[i
].jpg
.frag_tab
= (__le32
*)mem
;
334 fh
->buffers
.buffer
[i
].jpg
.frag_tab_bus
= virt_to_bus(mem
);
336 if (fh
->buffers
.need_contiguous
) {
337 mem
= kmalloc(fh
->buffers
.buffer_size
, GFP_KERNEL
);
341 "%s: %s - kmalloc failed for buffer %d\n",
342 ZR_DEVNAME(zr
), __func__
, i
);
343 jpg_fbuffer_free(fh
);
346 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[0] =
347 cpu_to_le32(virt_to_bus(mem
));
348 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[1] =
349 cpu_to_le32((fh
->buffers
.buffer_size
>> 1) | 1);
350 for (off
= 0; off
< fh
->buffers
.buffer_size
; off
+= PAGE_SIZE
)
351 SetPageReserved(virt_to_page(mem
+ off
));
353 /* jpg_bufsize is already page aligned */
354 for (j
= 0; j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
; j
++) {
355 mem
= (void *)get_zeroed_page(GFP_KERNEL
);
359 "%s: %s - get_zeroed_page failed for buffer %d\n",
360 ZR_DEVNAME(zr
), __func__
, i
);
361 jpg_fbuffer_free(fh
);
365 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
] =
366 cpu_to_le32(virt_to_bus(mem
));
367 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
+ 1] =
368 cpu_to_le32((PAGE_SIZE
>> 2) << 1);
369 SetPageReserved(virt_to_page(mem
));
372 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
- 1] |= cpu_to_le32(1);
377 KERN_DEBUG
"%s: %s - %d KB allocated\n",
378 ZR_DEVNAME(zr
), __func__
,
379 (fh
->buffers
.num_buffers
* fh
->buffers
.buffer_size
) >> 10);
381 fh
->buffers
.allocated
= 1;
386 /* free the MJPEG grab buffers */
387 static void jpg_fbuffer_free(struct zoran_fh
*fh
)
389 struct zoran
*zr
= fh
->zr
;
393 struct zoran_buffer
*buffer
;
395 dprintk(4, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
397 for (i
= 0, buffer
= &fh
->buffers
.buffer
[0];
398 i
< fh
->buffers
.num_buffers
; i
++, buffer
++) {
399 if (!buffer
->jpg
.frag_tab
)
402 if (fh
->buffers
.need_contiguous
) {
403 frag_tab
= buffer
->jpg
.frag_tab
[0];
406 mem
= bus_to_virt(le32_to_cpu(frag_tab
));
407 for (off
= 0; off
< fh
->buffers
.buffer_size
; off
+= PAGE_SIZE
)
408 ClearPageReserved(virt_to_page(mem
+ off
));
410 buffer
->jpg
.frag_tab
[0] = 0;
411 buffer
->jpg
.frag_tab
[1] = 0;
414 for (j
= 0; j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
; j
++) {
415 frag_tab
= buffer
->jpg
.frag_tab
[2 * j
];
419 ClearPageReserved(virt_to_page(bus_to_virt(le32_to_cpu(frag_tab
))));
420 free_page((unsigned long)bus_to_virt(le32_to_cpu(frag_tab
)));
421 buffer
->jpg
.frag_tab
[2 * j
] = 0;
422 buffer
->jpg
.frag_tab
[2 * j
+ 1] = 0;
426 free_page((unsigned long)buffer
->jpg
.frag_tab
);
427 buffer
->jpg
.frag_tab
= NULL
;
430 fh
->buffers
.allocated
= 0;
434 * V4L Buffer grabbing
438 zoran_v4l_set_format (struct zoran_fh
*fh
,
441 const struct zoran_format
*format
)
443 struct zoran
*zr
= fh
->zr
;
446 /* Check size and format of the grab wanted */
448 if (height
< BUZ_MIN_HEIGHT
|| width
< BUZ_MIN_WIDTH
||
449 height
> BUZ_MAX_HEIGHT
|| width
> BUZ_MAX_WIDTH
) {
452 "%s: %s - wrong frame size (%dx%d)\n",
453 ZR_DEVNAME(zr
), __func__
, width
, height
);
457 bpp
= (format
->depth
+ 7) / 8;
459 /* Check against available buffer size */
460 if (height
* width
* bpp
> fh
->buffers
.buffer_size
) {
463 "%s: %s - video buffer size (%d kB) is too small\n",
464 ZR_DEVNAME(zr
), __func__
, fh
->buffers
.buffer_size
>> 10);
468 /* The video front end needs 4-byte alinged line sizes */
470 if ((bpp
== 2 && (width
& 1)) || (bpp
== 3 && (width
& 3))) {
473 "%s: %s - wrong frame alignment\n",
474 ZR_DEVNAME(zr
), __func__
);
478 fh
->v4l_settings
.width
= width
;
479 fh
->v4l_settings
.height
= height
;
480 fh
->v4l_settings
.format
= format
;
481 fh
->v4l_settings
.bytesperline
= bpp
* fh
->v4l_settings
.width
;
486 static int zoran_v4l_queue_frame(struct zoran_fh
*fh
, int num
)
488 struct zoran
*zr
= fh
->zr
;
492 if (!fh
->buffers
.allocated
) {
495 "%s: %s - buffers not yet allocated\n",
496 ZR_DEVNAME(zr
), __func__
);
500 /* No grabbing outside the buffer range! */
501 if (num
>= fh
->buffers
.num_buffers
|| num
< 0) {
504 "%s: %s - buffer %d is out of range\n",
505 ZR_DEVNAME(zr
), __func__
, num
);
509 spin_lock_irqsave(&zr
->spinlock
, flags
);
511 if (fh
->buffers
.active
== ZORAN_FREE
) {
512 if (zr
->v4l_buffers
.active
== ZORAN_FREE
) {
513 zr
->v4l_buffers
= fh
->buffers
;
514 fh
->buffers
.active
= ZORAN_ACTIVE
;
518 "%s: %s - another session is already capturing\n",
519 ZR_DEVNAME(zr
), __func__
);
524 /* make sure a grab isn't going on currently with this buffer */
526 switch (zr
->v4l_buffers
.buffer
[num
].state
) {
529 if (zr
->v4l_buffers
.active
== ZORAN_FREE
) {
530 fh
->buffers
.active
= ZORAN_FREE
;
531 zr
->v4l_buffers
.allocated
= 0;
533 res
= -EBUSY
; /* what are you doing? */
538 "%s: %s - queueing buffer %d in state DONE!?\n",
539 ZR_DEVNAME(zr
), __func__
, num
);
541 /* since there is at least one unused buffer there's room for at least
542 * one more pend[] entry */
543 zr
->v4l_pend
[zr
->v4l_pend_head
++ & V4L_MASK_FRAME
] = num
;
544 zr
->v4l_buffers
.buffer
[num
].state
= BUZ_STATE_PEND
;
545 zr
->v4l_buffers
.buffer
[num
].bs
.length
=
546 fh
->v4l_settings
.bytesperline
*
547 zr
->v4l_settings
.height
;
548 fh
->buffers
.buffer
[num
] = zr
->v4l_buffers
.buffer
[num
];
553 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
555 if (!res
&& zr
->v4l_buffers
.active
== ZORAN_FREE
)
556 zr
->v4l_buffers
.active
= fh
->buffers
.active
;
562 * Sync on a V4L buffer
565 static int v4l_sync(struct zoran_fh
*fh
, int frame
)
567 struct zoran
*zr
= fh
->zr
;
570 if (fh
->buffers
.active
== ZORAN_FREE
) {
573 "%s: %s - no grab active for this session\n",
574 ZR_DEVNAME(zr
), __func__
);
578 /* check passed-in frame number */
579 if (frame
>= fh
->buffers
.num_buffers
|| frame
< 0) {
581 KERN_ERR
"%s: %s - frame %d is invalid\n",
582 ZR_DEVNAME(zr
), __func__
, frame
);
586 /* Check if is buffer was queued at all */
587 if (zr
->v4l_buffers
.buffer
[frame
].state
== BUZ_STATE_USER
) {
590 "%s: %s - attempt to sync on a buffer which was not queued?\n",
591 ZR_DEVNAME(zr
), __func__
);
595 /* wait on this buffer to get ready */
596 if (!wait_event_interruptible_timeout(zr
->v4l_capq
,
597 (zr
->v4l_buffers
.buffer
[frame
].state
!= BUZ_STATE_PEND
), 10*HZ
))
599 if (signal_pending(current
))
602 /* buffer should now be in BUZ_STATE_DONE */
603 if (zr
->v4l_buffers
.buffer
[frame
].state
!= BUZ_STATE_DONE
)
605 KERN_ERR
"%s: %s - internal state error\n",
606 ZR_DEVNAME(zr
), __func__
);
608 zr
->v4l_buffers
.buffer
[frame
].state
= BUZ_STATE_USER
;
609 fh
->buffers
.buffer
[frame
] = zr
->v4l_buffers
.buffer
[frame
];
611 spin_lock_irqsave(&zr
->spinlock
, flags
);
613 /* Check if streaming capture has finished */
614 if (zr
->v4l_pend_tail
== zr
->v4l_pend_head
) {
615 zr36057_set_memgrab(zr
, 0);
616 if (zr
->v4l_buffers
.active
== ZORAN_ACTIVE
) {
617 fh
->buffers
.active
= zr
->v4l_buffers
.active
= ZORAN_FREE
;
618 zr
->v4l_buffers
.allocated
= 0;
622 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
628 * Queue a MJPEG buffer for capture/playback
631 static int zoran_jpg_queue_frame(struct zoran_fh
*fh
, int num
,
632 enum zoran_codec_mode mode
)
634 struct zoran
*zr
= fh
->zr
;
638 /* Check if buffers are allocated */
639 if (!fh
->buffers
.allocated
) {
642 "%s: %s - buffers not yet allocated\n",
643 ZR_DEVNAME(zr
), __func__
);
647 /* No grabbing outside the buffer range! */
648 if (num
>= fh
->buffers
.num_buffers
|| num
< 0) {
651 "%s: %s - buffer %d out of range\n",
652 ZR_DEVNAME(zr
), __func__
, num
);
656 /* what is the codec mode right now? */
657 if (zr
->codec_mode
== BUZ_MODE_IDLE
) {
658 zr
->jpg_settings
= fh
->jpg_settings
;
659 } else if (zr
->codec_mode
!= mode
) {
660 /* wrong codec mode active - invalid */
663 "%s: %s - codec in wrong mode\n",
664 ZR_DEVNAME(zr
), __func__
);
668 if (fh
->buffers
.active
== ZORAN_FREE
) {
669 if (zr
->jpg_buffers
.active
== ZORAN_FREE
) {
670 zr
->jpg_buffers
= fh
->buffers
;
671 fh
->buffers
.active
= ZORAN_ACTIVE
;
675 "%s: %s - another session is already capturing\n",
676 ZR_DEVNAME(zr
), __func__
);
681 if (!res
&& zr
->codec_mode
== BUZ_MODE_IDLE
) {
682 /* Ok load up the jpeg codec */
683 zr36057_enable_jpg(zr
, mode
);
686 spin_lock_irqsave(&zr
->spinlock
, flags
);
689 switch (zr
->jpg_buffers
.buffer
[num
].state
) {
693 "%s: %s - queing frame in BUZ_STATE_DONE state!?\n",
694 ZR_DEVNAME(zr
), __func__
);
696 /* since there is at least one unused buffer there's room for at
697 *least one more pend[] entry */
698 zr
->jpg_pend
[zr
->jpg_que_head
++ & BUZ_MASK_FRAME
] = num
;
699 zr
->jpg_buffers
.buffer
[num
].state
= BUZ_STATE_PEND
;
700 fh
->buffers
.buffer
[num
] = zr
->jpg_buffers
.buffer
[num
];
701 zoran_feed_stat_com(zr
);
706 if (zr
->jpg_buffers
.active
== ZORAN_FREE
) {
707 fh
->buffers
.active
= ZORAN_FREE
;
708 zr
->jpg_buffers
.allocated
= 0;
710 res
= -EBUSY
; /* what are you doing? */
715 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
717 if (!res
&& zr
->jpg_buffers
.active
== ZORAN_FREE
)
718 zr
->jpg_buffers
.active
= fh
->buffers
.active
;
723 static int jpg_qbuf(struct zoran_fh
*fh
, int frame
, enum zoran_codec_mode mode
)
725 struct zoran
*zr
= fh
->zr
;
728 /* Does the user want to stop streaming? */
730 if (zr
->codec_mode
== mode
) {
731 if (fh
->buffers
.active
== ZORAN_FREE
) {
734 "%s: %s(-1) - session not active\n",
735 ZR_DEVNAME(zr
), __func__
);
738 fh
->buffers
.active
= zr
->jpg_buffers
.active
= ZORAN_FREE
;
739 zr
->jpg_buffers
.allocated
= 0;
740 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
745 "%s: %s - stop streaming but not in streaming mode\n",
746 ZR_DEVNAME(zr
), __func__
);
751 if ((res
= zoran_jpg_queue_frame(fh
, frame
, mode
)))
754 /* Start the jpeg codec when the first frame is queued */
755 if (!res
&& zr
->jpg_que_head
== 1)
762 * Sync on a MJPEG buffer
765 static int jpg_sync(struct zoran_fh
*fh
, struct zoran_sync
*bs
)
767 struct zoran
*zr
= fh
->zr
;
771 if (fh
->buffers
.active
== ZORAN_FREE
) {
774 "%s: %s - capture is not currently active\n",
775 ZR_DEVNAME(zr
), __func__
);
778 if (zr
->codec_mode
!= BUZ_MODE_MOTION_DECOMPRESS
&&
779 zr
->codec_mode
!= BUZ_MODE_MOTION_COMPRESS
) {
782 "%s: %s - codec not in streaming mode\n",
783 ZR_DEVNAME(zr
), __func__
);
786 if (!wait_event_interruptible_timeout(zr
->jpg_capq
,
787 (zr
->jpg_que_tail
!= zr
->jpg_dma_tail
||
788 zr
->jpg_dma_tail
== zr
->jpg_dma_head
),
792 btand(~ZR36057_JMC_Go_en
, ZR36057_JMC
);
794 zr
->codec
->control(zr
->codec
, CODEC_G_STATUS
,
798 "%s: %s - timeout: codec isr=0x%02x\n",
799 ZR_DEVNAME(zr
), __func__
, isr
);
804 if (signal_pending(current
))
807 spin_lock_irqsave(&zr
->spinlock
, flags
);
809 if (zr
->jpg_dma_tail
!= zr
->jpg_dma_head
)
810 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
++ & BUZ_MASK_FRAME
];
812 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
814 /* buffer should now be in BUZ_STATE_DONE */
815 if (zr
->jpg_buffers
.buffer
[frame
].state
!= BUZ_STATE_DONE
)
817 KERN_ERR
"%s: %s - internal state error\n",
818 ZR_DEVNAME(zr
), __func__
);
820 *bs
= zr
->jpg_buffers
.buffer
[frame
].bs
;
822 zr
->jpg_buffers
.buffer
[frame
].state
= BUZ_STATE_USER
;
823 fh
->buffers
.buffer
[frame
] = zr
->jpg_buffers
.buffer
[frame
];
825 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
830 static void zoran_open_init_session(struct zoran_fh
*fh
)
833 struct zoran
*zr
= fh
->zr
;
835 /* Per default, map the V4L Buffers */
838 /* take over the card's current settings */
839 fh
->overlay_settings
= zr
->overlay_settings
;
840 fh
->overlay_settings
.is_set
= 0;
841 fh
->overlay_settings
.format
= zr
->overlay_settings
.format
;
842 fh
->overlay_active
= ZORAN_FREE
;
845 fh
->v4l_settings
= zr
->v4l_settings
;
847 fh
->jpg_settings
= zr
->jpg_settings
;
850 memset(&fh
->buffers
, 0, sizeof(fh
->buffers
));
851 for (i
= 0; i
< MAX_FRAME
; i
++) {
852 fh
->buffers
.buffer
[i
].state
= BUZ_STATE_USER
; /* nothing going on */
853 fh
->buffers
.buffer
[i
].bs
.frame
= i
;
855 fh
->buffers
.allocated
= 0;
856 fh
->buffers
.active
= ZORAN_FREE
;
859 static void zoran_close_end_session(struct zoran_fh
*fh
)
861 struct zoran
*zr
= fh
->zr
;
864 if (fh
->overlay_active
!= ZORAN_FREE
) {
865 fh
->overlay_active
= zr
->overlay_active
= ZORAN_FREE
;
866 zr
->v4l_overlay_active
= 0;
867 if (!zr
->v4l_memgrab_active
)
868 zr36057_overlay(zr
, 0);
869 zr
->overlay_mask
= NULL
;
872 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
874 if (fh
->buffers
.active
!= ZORAN_FREE
) {
877 spin_lock_irqsave(&zr
->spinlock
, flags
);
878 zr36057_set_memgrab(zr
, 0);
879 zr
->v4l_buffers
.allocated
= 0;
880 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
881 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
885 if (fh
->buffers
.allocated
)
886 v4l_fbuffer_free(fh
);
889 if (fh
->buffers
.active
!= ZORAN_FREE
) {
890 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
891 zr
->jpg_buffers
.allocated
= 0;
892 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
896 if (fh
->buffers
.allocated
)
897 jpg_fbuffer_free(fh
);
902 * Open a zoran card. Right now the flags stuff is just playing
905 static int zoran_open(struct file
*file
)
907 struct zoran
*zr
= video_drvdata(file
);
909 int res
, first_open
= 0;
911 dprintk(2, KERN_INFO
"%s: %s(%s, pid=[%d]), users(-)=%d\n",
912 ZR_DEVNAME(zr
), __func__
, current
->comm
, task_pid_nr(current
), zr
->user
+ 1);
914 mutex_lock(&zr
->other_lock
);
916 if (zr
->user
>= 2048) {
917 dprintk(1, KERN_ERR
"%s: too many users (%d) on device\n",
918 ZR_DEVNAME(zr
), zr
->user
);
923 /* now, create the open()-specific file_ops struct */
924 fh
= kzalloc(sizeof(struct zoran_fh
), GFP_KERNEL
);
928 "%s: %s - allocation of zoran_fh failed\n",
929 ZR_DEVNAME(zr
), __func__
);
933 /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
936 kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL
);
937 if (!fh
->overlay_mask
) {
940 "%s: %s - allocation of overlay_mask failed\n",
941 ZR_DEVNAME(zr
), __func__
);
949 /*mutex_unlock(&zr->resource_lock);*/
951 /* default setup - TODO: look at flags */
952 if (first_open
) { /* First device open */
954 zoran_open_init_params(zr
);
955 zoran_init_hardware(zr
);
957 btor(ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
960 /* set file_ops stuff */
961 file
->private_data
= fh
;
963 zoran_open_init_session(fh
);
964 mutex_unlock(&zr
->other_lock
);
971 mutex_unlock(&zr
->other_lock
);
973 dprintk(2, KERN_INFO
"%s: open failed (%d), users(-)=%d\n",
974 ZR_DEVNAME(zr
), res
, zr
->user
);
980 zoran_close(struct file
*file
)
982 struct zoran_fh
*fh
= file
->private_data
;
983 struct zoran
*zr
= fh
->zr
;
985 dprintk(2, KERN_INFO
"%s: %s(%s, pid=[%d]), users(+)=%d\n",
986 ZR_DEVNAME(zr
), __func__
, current
->comm
, task_pid_nr(current
), zr
->user
- 1);
988 /* kernel locks (fs/device.c), so don't do that ourselves
989 * (prevents deadlocks) */
990 mutex_lock(&zr
->other_lock
);
992 zoran_close_end_session(fh
);
994 if (zr
->user
-- == 1) { /* Last process */
995 /* Clean up JPEG process */
996 wake_up_interruptible(&zr
->jpg_capq
);
997 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
998 zr
->jpg_buffers
.allocated
= 0;
999 zr
->jpg_buffers
.active
= ZORAN_FREE
;
1001 /* disable interrupts */
1002 btand(~ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
1004 if (zr36067_debug
> 1)
1005 print_interrupts(zr
);
1008 zr
->v4l_overlay_active
= 0;
1009 zr36057_overlay(zr
, 0);
1010 zr
->overlay_mask
= NULL
;
1013 wake_up_interruptible(&zr
->v4l_capq
);
1014 zr36057_set_memgrab(zr
, 0);
1015 zr
->v4l_buffers
.allocated
= 0;
1016 zr
->v4l_buffers
.active
= ZORAN_FREE
;
1017 zoran_set_pci_master(zr
, 0);
1019 if (!pass_through
) { /* Switch to color bar */
1020 decoder_call(zr
, video
, s_stream
, 0);
1021 encoder_call(zr
, video
, s_routing
, 2, 0, 0);
1024 mutex_unlock(&zr
->other_lock
);
1026 file
->private_data
= NULL
;
1027 kfree(fh
->overlay_mask
);
1030 dprintk(4, KERN_INFO
"%s: %s done\n", ZR_DEVNAME(zr
), __func__
);
1037 zoran_read (struct file
*file
,
1042 /* we simply don't support read() (yet)... */
1048 zoran_write (struct file
*file
,
1049 const char __user
*data
,
1053 /* ...and the same goes for write() */
1058 static int setup_fbuffer(struct zoran_fh
*fh
,
1060 const struct zoran_format
*fmt
,
1065 struct zoran
*zr
= fh
->zr
;
1067 /* (Ronald) v4l/v4l2 guidelines */
1068 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
1071 /* Don't allow frame buffer overlay if PCI or AGP is buggy, or on
1072 ALi Magik (that needs very low latency while the card needs a
1073 higher value always) */
1075 if (pci_pci_problems
& (PCIPCI_FAIL
| PCIAGP_FAIL
| PCIPCI_ALIMAGIK
))
1078 /* we need a bytesperline value, even if not given */
1080 bytesperline
= width
* ((fmt
->depth
+ 7) & ~7) / 8;
1083 if (zr
->overlay_active
) {
1084 /* dzjee... stupid users... don't even bother to turn off
1085 * overlay before changing the memory location...
1086 * normally, we would return errors here. However, one of
1087 * the tools that does this is... xawtv! and since xawtv
1088 * is used by +/- 99% of the users, we'd rather be user-
1089 * friendly and silently do as if nothing went wrong */
1092 "%s: %s - forced overlay turnoff because framebuffer changed\n",
1093 ZR_DEVNAME(zr
), __func__
);
1094 zr36057_overlay(zr
, 0);
1098 if (!(fmt
->flags
& ZORAN_FORMAT_OVERLAY
)) {
1101 "%s: %s - no valid overlay format given\n",
1102 ZR_DEVNAME(zr
), __func__
);
1105 if (height
<= 0 || width
<= 0 || bytesperline
<= 0) {
1108 "%s: %s - invalid height/width/bpl value (%d|%d|%d)\n",
1109 ZR_DEVNAME(zr
), __func__
, width
, height
, bytesperline
);
1112 if (bytesperline
& 3) {
1115 "%s: %s - bytesperline (%d) must be 4-byte aligned\n",
1116 ZR_DEVNAME(zr
), __func__
, bytesperline
);
1120 zr
->vbuf_base
= (void *) ((unsigned long) base
& ~3);
1121 zr
->vbuf_height
= height
;
1122 zr
->vbuf_width
= width
;
1123 zr
->vbuf_depth
= fmt
->depth
;
1124 zr
->overlay_settings
.format
= fmt
;
1125 zr
->vbuf_bytesperline
= bytesperline
;
1127 /* The user should set new window parameters */
1128 zr
->overlay_settings
.is_set
= 0;
1134 static int setup_window(struct zoran_fh
*fh
, int x
, int y
, int width
, int height
,
1135 struct v4l2_clip __user
*clips
, int clipcount
, void __user
*bitmap
)
1137 struct zoran
*zr
= fh
->zr
;
1138 struct v4l2_clip
*vcp
= NULL
;
1142 if (!zr
->vbuf_base
) {
1145 "%s: %s - frame buffer has to be set first\n",
1146 ZR_DEVNAME(zr
), __func__
);
1150 if (!fh
->overlay_settings
.format
) {
1153 "%s: %s - no overlay format set\n",
1154 ZR_DEVNAME(zr
), __func__
);
1159 * The video front end needs 4-byte alinged line sizes, we correct that
1160 * silently here if necessary
1162 if (zr
->vbuf_depth
== 15 || zr
->vbuf_depth
== 16) {
1163 end
= (x
+ width
) & ~1; /* round down */
1164 x
= (x
+ 1) & ~1; /* round up */
1168 if (zr
->vbuf_depth
== 24) {
1169 end
= (x
+ width
) & ~3; /* round down */
1170 x
= (x
+ 3) & ~3; /* round up */
1174 if (width
> BUZ_MAX_WIDTH
)
1175 width
= BUZ_MAX_WIDTH
;
1176 if (height
> BUZ_MAX_HEIGHT
)
1177 height
= BUZ_MAX_HEIGHT
;
1179 /* Check for invalid parameters */
1180 if (width
< BUZ_MIN_WIDTH
|| height
< BUZ_MIN_HEIGHT
||
1181 width
> BUZ_MAX_WIDTH
|| height
> BUZ_MAX_HEIGHT
) {
1184 "%s: %s - width = %d or height = %d invalid\n",
1185 ZR_DEVNAME(zr
), __func__
, width
, height
);
1189 fh
->overlay_settings
.x
= x
;
1190 fh
->overlay_settings
.y
= y
;
1191 fh
->overlay_settings
.width
= width
;
1192 fh
->overlay_settings
.height
= height
;
1193 fh
->overlay_settings
.clipcount
= clipcount
;
1196 * If an overlay is running, we have to switch it off
1197 * and switch it on again in order to get the new settings in effect.
1199 * We also want to avoid that the overlay mask is written
1200 * when an overlay is running.
1203 on
= zr
->v4l_overlay_active
&& !zr
->v4l_memgrab_active
&&
1204 zr
->overlay_active
!= ZORAN_FREE
&&
1205 fh
->overlay_active
!= ZORAN_FREE
;
1207 zr36057_overlay(zr
, 0);
1210 * Write the overlay mask if clips are wanted.
1211 * We prefer a bitmap.
1214 /* fake value - it just means we want clips */
1215 fh
->overlay_settings
.clipcount
= 1;
1217 if (copy_from_user(fh
->overlay_mask
, bitmap
,
1218 (width
* height
+ 7) / 8)) {
1221 } else if (clipcount
> 0) {
1222 /* write our own bitmap from the clips */
1223 vcp
= vmalloc(sizeof(struct v4l2_clip
) * (clipcount
+ 4));
1227 "%s: %s - Alloc of clip mask failed\n",
1228 ZR_DEVNAME(zr
), __func__
);
1232 (vcp
, clips
, sizeof(struct v4l2_clip
) * clipcount
)) {
1236 write_overlay_mask(fh
, vcp
, clipcount
);
1240 fh
->overlay_settings
.is_set
= 1;
1241 if (fh
->overlay_active
!= ZORAN_FREE
&&
1242 zr
->overlay_active
!= ZORAN_FREE
)
1243 zr
->overlay_settings
= fh
->overlay_settings
;
1246 zr36057_overlay(zr
, 1);
1248 /* Make sure the changes come into effect */
1249 return wait_grab_pending(zr
);
1252 static int setup_overlay(struct zoran_fh
*fh
, int on
)
1254 struct zoran
*zr
= fh
->zr
;
1256 /* If there is nothing to do, return immediately */
1257 if ((on
&& fh
->overlay_active
!= ZORAN_FREE
) ||
1258 (!on
&& fh
->overlay_active
== ZORAN_FREE
))
1261 /* check whether we're touching someone else's overlay */
1262 if (on
&& zr
->overlay_active
!= ZORAN_FREE
&&
1263 fh
->overlay_active
== ZORAN_FREE
) {
1266 "%s: %s - overlay is already active for another session\n",
1267 ZR_DEVNAME(zr
), __func__
);
1270 if (!on
&& zr
->overlay_active
!= ZORAN_FREE
&&
1271 fh
->overlay_active
== ZORAN_FREE
) {
1274 "%s: %s - you cannot cancel someone else's session\n",
1275 ZR_DEVNAME(zr
), __func__
);
1280 zr
->overlay_active
= fh
->overlay_active
= ZORAN_FREE
;
1281 zr
->v4l_overlay_active
= 0;
1282 /* When a grab is running, the video simply
1283 * won't be switched on any more */
1284 if (!zr
->v4l_memgrab_active
)
1285 zr36057_overlay(zr
, 0);
1286 zr
->overlay_mask
= NULL
;
1288 if (!zr
->vbuf_base
|| !fh
->overlay_settings
.is_set
) {
1291 "%s: %s - buffer or window not set\n",
1292 ZR_DEVNAME(zr
), __func__
);
1295 if (!fh
->overlay_settings
.format
) {
1298 "%s: %s - no overlay format set\n",
1299 ZR_DEVNAME(zr
), __func__
);
1302 zr
->overlay_active
= fh
->overlay_active
= ZORAN_LOCKED
;
1303 zr
->v4l_overlay_active
= 1;
1304 zr
->overlay_mask
= fh
->overlay_mask
;
1305 zr
->overlay_settings
= fh
->overlay_settings
;
1306 if (!zr
->v4l_memgrab_active
)
1307 zr36057_overlay(zr
, 1);
1308 /* When a grab is running, the video will be
1309 * switched on when grab is finished */
1312 /* Make sure the changes come into effect */
1313 return wait_grab_pending(zr
);
1316 /* get the status of a buffer in the clients buffer queue */
1317 static int zoran_v4l2_buffer_status(struct zoran_fh
*fh
,
1318 struct v4l2_buffer
*buf
, int num
)
1320 struct zoran
*zr
= fh
->zr
;
1321 unsigned long flags
;
1323 buf
->flags
= V4L2_BUF_FLAG_MAPPED
;
1325 switch (fh
->map_mode
) {
1326 case ZORAN_MAP_MODE_RAW
:
1328 if (num
< 0 || num
>= fh
->buffers
.num_buffers
||
1329 !fh
->buffers
.allocated
) {
1332 "%s: %s - wrong number or buffers not allocated\n",
1333 ZR_DEVNAME(zr
), __func__
);
1337 spin_lock_irqsave(&zr
->spinlock
, flags
);
1340 "%s: %s() - raw active=%c, buffer %d: state=%c, map=%c\n",
1341 ZR_DEVNAME(zr
), __func__
,
1342 "FAL"[fh
->buffers
.active
], num
,
1343 "UPMD"[zr
->v4l_buffers
.buffer
[num
].state
],
1344 fh
->buffers
.buffer
[num
].map
? 'Y' : 'N');
1345 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
1347 buf
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1348 buf
->length
= fh
->buffers
.buffer_size
;
1351 buf
->bytesused
= fh
->buffers
.buffer
[num
].bs
.length
;
1352 if (fh
->buffers
.buffer
[num
].state
== BUZ_STATE_DONE
||
1353 fh
->buffers
.buffer
[num
].state
== BUZ_STATE_USER
) {
1354 buf
->sequence
= fh
->buffers
.buffer
[num
].bs
.seq
;
1355 buf
->flags
|= V4L2_BUF_FLAG_DONE
;
1356 buf
->timestamp
= fh
->buffers
.buffer
[num
].bs
.timestamp
;
1358 buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1361 if (fh
->v4l_settings
.height
<= BUZ_MAX_HEIGHT
/ 2)
1362 buf
->field
= V4L2_FIELD_TOP
;
1364 buf
->field
= V4L2_FIELD_INTERLACED
;
1368 case ZORAN_MAP_MODE_JPG_REC
:
1369 case ZORAN_MAP_MODE_JPG_PLAY
:
1372 if (num
< 0 || num
>= fh
->buffers
.num_buffers
||
1373 !fh
->buffers
.allocated
) {
1376 "%s: %s - wrong number or buffers not allocated\n",
1377 ZR_DEVNAME(zr
), __func__
);
1381 buf
->type
= (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
) ?
1382 V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1383 V4L2_BUF_TYPE_VIDEO_OUTPUT
;
1384 buf
->length
= fh
->buffers
.buffer_size
;
1386 /* these variables are only written after frame has been captured */
1387 if (fh
->buffers
.buffer
[num
].state
== BUZ_STATE_DONE
||
1388 fh
->buffers
.buffer
[num
].state
== BUZ_STATE_USER
) {
1389 buf
->sequence
= fh
->buffers
.buffer
[num
].bs
.seq
;
1390 buf
->timestamp
= fh
->buffers
.buffer
[num
].bs
.timestamp
;
1391 buf
->bytesused
= fh
->buffers
.buffer
[num
].bs
.length
;
1392 buf
->flags
|= V4L2_BUF_FLAG_DONE
;
1394 buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1397 /* which fields are these? */
1398 if (fh
->jpg_settings
.TmpDcm
!= 1)
1399 buf
->field
= fh
->jpg_settings
.odd_even
?
1400 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
;
1402 buf
->field
= fh
->jpg_settings
.odd_even
?
1403 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
;
1411 "%s: %s - invalid buffer type|map_mode (%d|%d)\n",
1412 ZR_DEVNAME(zr
), __func__
, buf
->type
, fh
->map_mode
);
1416 buf
->memory
= V4L2_MEMORY_MMAP
;
1418 buf
->m
.offset
= buf
->length
* num
;
1424 zoran_set_norm (struct zoran
*zr
,
1429 if (zr
->v4l_buffers
.active
!= ZORAN_FREE
||
1430 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
1433 "%s: %s called while in playback/capture mode\n",
1434 ZR_DEVNAME(zr
), __func__
);
1438 if (!(norm
& zr
->card
.norms
)) {
1440 KERN_ERR
"%s: %s - unsupported norm %llx\n",
1441 ZR_DEVNAME(zr
), __func__
, norm
);
1445 if (norm
== V4L2_STD_ALL
) {
1446 unsigned int status
= 0;
1447 v4l2_std_id std
= 0;
1449 decoder_call(zr
, video
, querystd
, &std
);
1450 decoder_call(zr
, core
, s_std
, std
);
1452 /* let changes come into effect */
1455 decoder_call(zr
, video
, g_input_status
, &status
);
1456 if (status
& V4L2_IN_ST_NO_SIGNAL
) {
1459 "%s: %s - no norm detected\n",
1460 ZR_DEVNAME(zr
), __func__
);
1462 decoder_call(zr
, core
, s_std
, zr
->norm
);
1468 if (norm
& V4L2_STD_SECAM
)
1469 zr
->timing
= zr
->card
.tvn
[2];
1470 else if (norm
& V4L2_STD_NTSC
)
1471 zr
->timing
= zr
->card
.tvn
[1];
1473 zr
->timing
= zr
->card
.tvn
[0];
1475 /* We switch overlay off and on since a change in the
1476 * norm needs different VFE settings */
1477 on
= zr
->overlay_active
&& !zr
->v4l_memgrab_active
;
1479 zr36057_overlay(zr
, 0);
1481 decoder_call(zr
, core
, s_std
, norm
);
1482 encoder_call(zr
, video
, s_std_output
, norm
);
1485 zr36057_overlay(zr
, 1);
1487 /* Make sure the changes come into effect */
1494 zoran_set_input (struct zoran
*zr
,
1497 if (input
== zr
->input
) {
1501 if (zr
->v4l_buffers
.active
!= ZORAN_FREE
||
1502 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
1505 "%s: %s called while in playback/capture mode\n",
1506 ZR_DEVNAME(zr
), __func__
);
1510 if (input
< 0 || input
>= zr
->card
.inputs
) {
1513 "%s: %s - unnsupported input %d\n",
1514 ZR_DEVNAME(zr
), __func__
, input
);
1520 decoder_call(zr
, video
, s_routing
,
1521 zr
->card
.input
[input
].muxsel
, 0, 0);
1530 static int zoran_querycap(struct file
*file
, void *__fh
, struct v4l2_capability
*cap
)
1532 struct zoran_fh
*fh
= __fh
;
1533 struct zoran
*zr
= fh
->zr
;
1535 memset(cap
, 0, sizeof(*cap
));
1536 strncpy(cap
->card
, ZR_DEVNAME(zr
), sizeof(cap
->card
)-1);
1537 strncpy(cap
->driver
, "zoran", sizeof(cap
->driver
)-1);
1538 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "PCI:%s",
1539 pci_name(zr
->pci_dev
));
1540 cap
->capabilities
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_CAPTURE
|
1541 V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_VIDEO_OVERLAY
;
1545 static int zoran_enum_fmt(struct zoran
*zr
, struct v4l2_fmtdesc
*fmt
, int flag
)
1547 unsigned int num
, i
;
1549 for (num
= i
= 0; i
< NUM_FORMATS
; i
++) {
1550 if (zoran_formats
[i
].flags
& flag
&& num
++ == fmt
->index
) {
1551 strncpy(fmt
->description
, zoran_formats
[i
].name
,
1552 sizeof(fmt
->description
) - 1);
1553 /* fmt struct pre-zeroed, so adding '\0' not neeed */
1554 fmt
->pixelformat
= zoran_formats
[i
].fourcc
;
1555 if (zoran_formats
[i
].flags
& ZORAN_FORMAT_COMPRESSED
)
1556 fmt
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
1563 static int zoran_enum_fmt_vid_cap(struct file
*file
, void *__fh
,
1564 struct v4l2_fmtdesc
*f
)
1566 struct zoran_fh
*fh
= __fh
;
1567 struct zoran
*zr
= fh
->zr
;
1569 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_CAPTURE
);
1572 static int zoran_enum_fmt_vid_out(struct file
*file
, void *__fh
,
1573 struct v4l2_fmtdesc
*f
)
1575 struct zoran_fh
*fh
= __fh
;
1576 struct zoran
*zr
= fh
->zr
;
1578 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_PLAYBACK
);
1581 static int zoran_enum_fmt_vid_overlay(struct file
*file
, void *__fh
,
1582 struct v4l2_fmtdesc
*f
)
1584 struct zoran_fh
*fh
= __fh
;
1585 struct zoran
*zr
= fh
->zr
;
1587 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_OVERLAY
);
1590 static int zoran_g_fmt_vid_out(struct file
*file
, void *__fh
,
1591 struct v4l2_format
*fmt
)
1593 struct zoran_fh
*fh
= __fh
;
1594 struct zoran
*zr
= fh
->zr
;
1596 mutex_lock(&zr
->resource_lock
);
1598 fmt
->fmt
.pix
.width
= fh
->jpg_settings
.img_width
/ fh
->jpg_settings
.HorDcm
;
1599 fmt
->fmt
.pix
.height
= fh
->jpg_settings
.img_height
* 2 /
1600 (fh
->jpg_settings
.VerDcm
* fh
->jpg_settings
.TmpDcm
);
1601 fmt
->fmt
.pix
.sizeimage
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
1602 fmt
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_MJPEG
;
1603 if (fh
->jpg_settings
.TmpDcm
== 1)
1604 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1605 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1607 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1608 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1609 fmt
->fmt
.pix
.bytesperline
= 0;
1610 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1612 mutex_unlock(&zr
->resource_lock
);
1616 static int zoran_g_fmt_vid_cap(struct file
*file
, void *__fh
,
1617 struct v4l2_format
*fmt
)
1619 struct zoran_fh
*fh
= __fh
;
1620 struct zoran
*zr
= fh
->zr
;
1622 if (fh
->map_mode
!= ZORAN_MAP_MODE_RAW
)
1623 return zoran_g_fmt_vid_out(file
, fh
, fmt
);
1625 mutex_lock(&zr
->resource_lock
);
1626 fmt
->fmt
.pix
.width
= fh
->v4l_settings
.width
;
1627 fmt
->fmt
.pix
.height
= fh
->v4l_settings
.height
;
1628 fmt
->fmt
.pix
.sizeimage
= fh
->v4l_settings
.bytesperline
*
1629 fh
->v4l_settings
.height
;
1630 fmt
->fmt
.pix
.pixelformat
= fh
->v4l_settings
.format
->fourcc
;
1631 fmt
->fmt
.pix
.colorspace
= fh
->v4l_settings
.format
->colorspace
;
1632 fmt
->fmt
.pix
.bytesperline
= fh
->v4l_settings
.bytesperline
;
1633 if (BUZ_MAX_HEIGHT
< (fh
->v4l_settings
.height
* 2))
1634 fmt
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1636 fmt
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
1637 mutex_unlock(&zr
->resource_lock
);
1641 static int zoran_g_fmt_vid_overlay(struct file
*file
, void *__fh
,
1642 struct v4l2_format
*fmt
)
1644 struct zoran_fh
*fh
= __fh
;
1645 struct zoran
*zr
= fh
->zr
;
1647 mutex_lock(&zr
->resource_lock
);
1649 fmt
->fmt
.win
.w
.left
= fh
->overlay_settings
.x
;
1650 fmt
->fmt
.win
.w
.top
= fh
->overlay_settings
.y
;
1651 fmt
->fmt
.win
.w
.width
= fh
->overlay_settings
.width
;
1652 fmt
->fmt
.win
.w
.height
= fh
->overlay_settings
.height
;
1653 if (fh
->overlay_settings
.width
* 2 > BUZ_MAX_HEIGHT
)
1654 fmt
->fmt
.win
.field
= V4L2_FIELD_INTERLACED
;
1656 fmt
->fmt
.win
.field
= V4L2_FIELD_TOP
;
1658 mutex_unlock(&zr
->resource_lock
);
1662 static int zoran_try_fmt_vid_overlay(struct file
*file
, void *__fh
,
1663 struct v4l2_format
*fmt
)
1665 struct zoran_fh
*fh
= __fh
;
1666 struct zoran
*zr
= fh
->zr
;
1668 mutex_lock(&zr
->resource_lock
);
1670 if (fmt
->fmt
.win
.w
.width
> BUZ_MAX_WIDTH
)
1671 fmt
->fmt
.win
.w
.width
= BUZ_MAX_WIDTH
;
1672 if (fmt
->fmt
.win
.w
.width
< BUZ_MIN_WIDTH
)
1673 fmt
->fmt
.win
.w
.width
= BUZ_MIN_WIDTH
;
1674 if (fmt
->fmt
.win
.w
.height
> BUZ_MAX_HEIGHT
)
1675 fmt
->fmt
.win
.w
.height
= BUZ_MAX_HEIGHT
;
1676 if (fmt
->fmt
.win
.w
.height
< BUZ_MIN_HEIGHT
)
1677 fmt
->fmt
.win
.w
.height
= BUZ_MIN_HEIGHT
;
1679 mutex_unlock(&zr
->resource_lock
);
1683 static int zoran_try_fmt_vid_out(struct file
*file
, void *__fh
,
1684 struct v4l2_format
*fmt
)
1686 struct zoran_fh
*fh
= __fh
;
1687 struct zoran
*zr
= fh
->zr
;
1688 struct zoran_jpg_settings settings
;
1691 if (fmt
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
1694 mutex_lock(&zr
->resource_lock
);
1695 settings
= fh
->jpg_settings
;
1697 /* we actually need to set 'real' parameters now */
1698 if ((fmt
->fmt
.pix
.height
* 2) > BUZ_MAX_HEIGHT
)
1699 settings
.TmpDcm
= 1;
1701 settings
.TmpDcm
= 2;
1702 settings
.decimation
= 0;
1703 if (fmt
->fmt
.pix
.height
<= fh
->jpg_settings
.img_height
/ 2)
1704 settings
.VerDcm
= 2;
1706 settings
.VerDcm
= 1;
1707 if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 4)
1708 settings
.HorDcm
= 4;
1709 else if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 2)
1710 settings
.HorDcm
= 2;
1712 settings
.HorDcm
= 1;
1713 if (settings
.TmpDcm
== 1)
1714 settings
.field_per_buff
= 2;
1716 settings
.field_per_buff
= 1;
1718 if (settings
.HorDcm
> 1) {
1719 settings
.img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
1720 settings
.img_width
= (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
1723 settings
.img_width
= BUZ_MAX_WIDTH
;
1727 res
= zoran_check_jpg_settings(zr
, &settings
, 1);
1729 goto tryfmt_unlock_and_return
;
1731 /* tell the user what we actually did */
1732 fmt
->fmt
.pix
.width
= settings
.img_width
/ settings
.HorDcm
;
1733 fmt
->fmt
.pix
.height
= settings
.img_height
* 2 /
1734 (settings
.TmpDcm
* settings
.VerDcm
);
1735 if (settings
.TmpDcm
== 1)
1736 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1737 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1739 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1740 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1742 fmt
->fmt
.pix
.sizeimage
= zoran_v4l2_calc_bufsize(&settings
);
1743 fmt
->fmt
.pix
.bytesperline
= 0;
1744 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1745 tryfmt_unlock_and_return
:
1746 mutex_unlock(&zr
->resource_lock
);
1750 static int zoran_try_fmt_vid_cap(struct file
*file
, void *__fh
,
1751 struct v4l2_format
*fmt
)
1753 struct zoran_fh
*fh
= __fh
;
1754 struct zoran
*zr
= fh
->zr
;
1758 if (fmt
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_MJPEG
)
1759 return zoran_try_fmt_vid_out(file
, fh
, fmt
);
1761 mutex_lock(&zr
->resource_lock
);
1763 for (i
= 0; i
< NUM_FORMATS
; i
++)
1764 if (zoran_formats
[i
].fourcc
== fmt
->fmt
.pix
.pixelformat
)
1767 if (i
== NUM_FORMATS
) {
1768 mutex_unlock(&zr
->resource_lock
);
1772 bpp
= DIV_ROUND_UP(zoran_formats
[i
].depth
, 8);
1773 v4l_bound_align_image(
1774 &fmt
->fmt
.pix
.width
, BUZ_MIN_WIDTH
, BUZ_MAX_WIDTH
, bpp
== 2 ? 1 : 2,
1775 &fmt
->fmt
.pix
.height
, BUZ_MIN_HEIGHT
, BUZ_MAX_HEIGHT
, 0, 0);
1776 mutex_unlock(&zr
->resource_lock
);
1781 static int zoran_s_fmt_vid_overlay(struct file
*file
, void *__fh
,
1782 struct v4l2_format
*fmt
)
1784 struct zoran_fh
*fh
= __fh
;
1785 struct zoran
*zr
= fh
->zr
;
1788 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
1789 fmt
->fmt
.win
.w
.left
, fmt
->fmt
.win
.w
.top
,
1790 fmt
->fmt
.win
.w
.width
,
1791 fmt
->fmt
.win
.w
.height
,
1792 fmt
->fmt
.win
.clipcount
,
1793 fmt
->fmt
.win
.bitmap
);
1794 mutex_lock(&zr
->resource_lock
);
1795 res
= setup_window(fh
, fmt
->fmt
.win
.w
.left
, fmt
->fmt
.win
.w
.top
,
1796 fmt
->fmt
.win
.w
.width
, fmt
->fmt
.win
.w
.height
,
1797 (struct v4l2_clip __user
*)fmt
->fmt
.win
.clips
,
1798 fmt
->fmt
.win
.clipcount
, fmt
->fmt
.win
.bitmap
);
1799 mutex_unlock(&zr
->resource_lock
);
1803 static int zoran_s_fmt_vid_out(struct file
*file
, void *__fh
,
1804 struct v4l2_format
*fmt
)
1806 struct zoran_fh
*fh
= __fh
;
1807 struct zoran
*zr
= fh
->zr
;
1808 __le32 printformat
= __cpu_to_le32(fmt
->fmt
.pix
.pixelformat
);
1809 struct zoran_jpg_settings settings
;
1812 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
1813 fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
,
1814 fmt
->fmt
.pix
.pixelformat
,
1815 (char *) &printformat
);
1816 if (fmt
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
1819 mutex_lock(&zr
->resource_lock
);
1821 if (fh
->buffers
.allocated
) {
1822 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - cannot change capture mode\n",
1825 goto sfmtjpg_unlock_and_return
;
1828 settings
= fh
->jpg_settings
;
1830 /* we actually need to set 'real' parameters now */
1831 if (fmt
->fmt
.pix
.height
* 2 > BUZ_MAX_HEIGHT
)
1832 settings
.TmpDcm
= 1;
1834 settings
.TmpDcm
= 2;
1835 settings
.decimation
= 0;
1836 if (fmt
->fmt
.pix
.height
<= fh
->jpg_settings
.img_height
/ 2)
1837 settings
.VerDcm
= 2;
1839 settings
.VerDcm
= 1;
1840 if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 4)
1841 settings
.HorDcm
= 4;
1842 else if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 2)
1843 settings
.HorDcm
= 2;
1845 settings
.HorDcm
= 1;
1846 if (settings
.TmpDcm
== 1)
1847 settings
.field_per_buff
= 2;
1849 settings
.field_per_buff
= 1;
1851 if (settings
.HorDcm
> 1) {
1852 settings
.img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
1853 settings
.img_width
= (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
1856 settings
.img_width
= BUZ_MAX_WIDTH
;
1860 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
1862 goto sfmtjpg_unlock_and_return
;
1864 /* it's ok, so set them */
1865 fh
->jpg_settings
= settings
;
1867 map_mode_jpg(fh
, fmt
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
);
1868 fh
->buffers
.buffer_size
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
1870 /* tell the user what we actually did */
1871 fmt
->fmt
.pix
.width
= settings
.img_width
/ settings
.HorDcm
;
1872 fmt
->fmt
.pix
.height
= settings
.img_height
* 2 /
1873 (settings
.TmpDcm
* settings
.VerDcm
);
1874 if (settings
.TmpDcm
== 1)
1875 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1876 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1878 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1879 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1880 fmt
->fmt
.pix
.bytesperline
= 0;
1881 fmt
->fmt
.pix
.sizeimage
= fh
->buffers
.buffer_size
;
1882 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1884 sfmtjpg_unlock_and_return
:
1885 mutex_unlock(&zr
->resource_lock
);
1889 static int zoran_s_fmt_vid_cap(struct file
*file
, void *__fh
,
1890 struct v4l2_format
*fmt
)
1892 struct zoran_fh
*fh
= __fh
;
1893 struct zoran
*zr
= fh
->zr
;
1897 if (fmt
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_MJPEG
)
1898 return zoran_s_fmt_vid_out(file
, fh
, fmt
);
1900 for (i
= 0; i
< NUM_FORMATS
; i
++)
1901 if (fmt
->fmt
.pix
.pixelformat
== zoran_formats
[i
].fourcc
)
1903 if (i
== NUM_FORMATS
) {
1904 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",
1905 ZR_DEVNAME(zr
), fmt
->fmt
.pix
.pixelformat
);
1909 mutex_lock(&zr
->resource_lock
);
1911 if ((fh
->map_mode
!= ZORAN_MAP_MODE_RAW
&& fh
->buffers
.allocated
) ||
1912 fh
->buffers
.active
!= ZORAN_FREE
) {
1913 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - cannot change capture mode\n",
1916 goto sfmtv4l_unlock_and_return
;
1918 if (fmt
->fmt
.pix
.height
> BUZ_MAX_HEIGHT
)
1919 fmt
->fmt
.pix
.height
= BUZ_MAX_HEIGHT
;
1920 if (fmt
->fmt
.pix
.width
> BUZ_MAX_WIDTH
)
1921 fmt
->fmt
.pix
.width
= BUZ_MAX_WIDTH
;
1925 res
= zoran_v4l_set_format(fh
, fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
,
1928 goto sfmtv4l_unlock_and_return
;
1930 /* tell the user the results/missing stuff */
1931 fmt
->fmt
.pix
.bytesperline
= fh
->v4l_settings
.bytesperline
;
1932 fmt
->fmt
.pix
.sizeimage
= fh
->v4l_settings
.height
* fh
->v4l_settings
.bytesperline
;
1933 fmt
->fmt
.pix
.colorspace
= fh
->v4l_settings
.format
->colorspace
;
1934 if (BUZ_MAX_HEIGHT
< (fh
->v4l_settings
.height
* 2))
1935 fmt
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1937 fmt
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
1939 sfmtv4l_unlock_and_return
:
1940 mutex_unlock(&zr
->resource_lock
);
1944 static int zoran_g_fbuf(struct file
*file
, void *__fh
,
1945 struct v4l2_framebuffer
*fb
)
1947 struct zoran_fh
*fh
= __fh
;
1948 struct zoran
*zr
= fh
->zr
;
1950 memset(fb
, 0, sizeof(*fb
));
1951 mutex_lock(&zr
->resource_lock
);
1952 fb
->base
= zr
->vbuf_base
;
1953 fb
->fmt
.width
= zr
->vbuf_width
;
1954 fb
->fmt
.height
= zr
->vbuf_height
;
1955 if (zr
->overlay_settings
.format
)
1956 fb
->fmt
.pixelformat
= fh
->overlay_settings
.format
->fourcc
;
1957 fb
->fmt
.bytesperline
= zr
->vbuf_bytesperline
;
1958 mutex_unlock(&zr
->resource_lock
);
1959 fb
->fmt
.colorspace
= V4L2_COLORSPACE_SRGB
;
1960 fb
->fmt
.field
= V4L2_FIELD_INTERLACED
;
1961 fb
->flags
= V4L2_FBUF_FLAG_OVERLAY
;
1962 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
1967 static int zoran_s_fbuf(struct file
*file
, void *__fh
,
1968 struct v4l2_framebuffer
*fb
)
1970 struct zoran_fh
*fh
= __fh
;
1971 struct zoran
*zr
= fh
->zr
;
1973 __le32 printformat
= __cpu_to_le32(fb
->fmt
.pixelformat
);
1975 for (i
= 0; i
< NUM_FORMATS
; i
++)
1976 if (zoran_formats
[i
].fourcc
== fb
->fmt
.pixelformat
)
1978 if (i
== NUM_FORMATS
) {
1979 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
1980 ZR_DEVNAME(zr
), fb
->fmt
.pixelformat
,
1981 (char *)&printformat
);
1985 mutex_lock(&zr
->resource_lock
);
1986 res
= setup_fbuffer(fh
, fb
->base
, &zoran_formats
[i
], fb
->fmt
.width
,
1987 fb
->fmt
.height
, fb
->fmt
.bytesperline
);
1988 mutex_unlock(&zr
->resource_lock
);
1993 static int zoran_overlay(struct file
*file
, void *__fh
, unsigned int on
)
1995 struct zoran_fh
*fh
= __fh
;
1996 struct zoran
*zr
= fh
->zr
;
1999 mutex_lock(&zr
->resource_lock
);
2000 res
= setup_overlay(fh
, on
);
2001 mutex_unlock(&zr
->resource_lock
);
2006 static int zoran_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
);
2008 static int zoran_reqbufs(struct file
*file
, void *__fh
, struct v4l2_requestbuffers
*req
)
2010 struct zoran_fh
*fh
= __fh
;
2011 struct zoran
*zr
= fh
->zr
;
2014 if (req
->memory
!= V4L2_MEMORY_MMAP
) {
2017 "%s: only MEMORY_MMAP capture is supported, not %d\n",
2018 ZR_DEVNAME(zr
), req
->memory
);
2022 if (req
->count
== 0)
2023 return zoran_streamoff(file
, fh
, req
->type
);
2025 mutex_lock(&zr
->resource_lock
);
2026 if (fh
->buffers
.allocated
) {
2029 "%s: VIDIOC_REQBUFS - buffers already allocated\n",
2032 goto v4l2reqbuf_unlock_and_return
;
2035 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
&&
2036 req
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2037 /* control user input */
2040 if (req
->count
> v4l_nbufs
)
2041 req
->count
= v4l_nbufs
;
2043 /* The next mmap will map the V4L buffers */
2045 fh
->buffers
.num_buffers
= req
->count
;
2047 if (v4l_fbuffer_alloc(fh
)) {
2049 goto v4l2reqbuf_unlock_and_return
;
2051 } else if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
||
2052 fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
) {
2053 /* we need to calculate size ourselves now */
2056 if (req
->count
> jpg_nbufs
)
2057 req
->count
= jpg_nbufs
;
2059 /* The next mmap will map the MJPEG buffers */
2060 map_mode_jpg(fh
, req
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
);
2061 fh
->buffers
.num_buffers
= req
->count
;
2062 fh
->buffers
.buffer_size
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
2064 if (jpg_fbuffer_alloc(fh
)) {
2066 goto v4l2reqbuf_unlock_and_return
;
2071 "%s: VIDIOC_REQBUFS - unknown type %d\n",
2072 ZR_DEVNAME(zr
), req
->type
);
2074 goto v4l2reqbuf_unlock_and_return
;
2076 v4l2reqbuf_unlock_and_return
:
2077 mutex_unlock(&zr
->resource_lock
);
2082 static int zoran_querybuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2084 struct zoran_fh
*fh
= __fh
;
2085 struct zoran
*zr
= fh
->zr
;
2088 mutex_lock(&zr
->resource_lock
);
2089 res
= zoran_v4l2_buffer_status(fh
, buf
, buf
->index
);
2090 mutex_unlock(&zr
->resource_lock
);
2095 static int zoran_qbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2097 struct zoran_fh
*fh
= __fh
;
2098 struct zoran
*zr
= fh
->zr
;
2099 int res
= 0, codec_mode
, buf_type
;
2101 mutex_lock(&zr
->resource_lock
);
2103 switch (fh
->map_mode
) {
2104 case ZORAN_MAP_MODE_RAW
:
2105 if (buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2107 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2108 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2110 goto qbuf_unlock_and_return
;
2113 res
= zoran_v4l_queue_frame(fh
, buf
->index
);
2115 goto qbuf_unlock_and_return
;
2116 if (!zr
->v4l_memgrab_active
&& fh
->buffers
.active
== ZORAN_LOCKED
)
2117 zr36057_set_memgrab(zr
, 1);
2120 case ZORAN_MAP_MODE_JPG_REC
:
2121 case ZORAN_MAP_MODE_JPG_PLAY
:
2122 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
) {
2123 buf_type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2124 codec_mode
= BUZ_MODE_MOTION_DECOMPRESS
;
2126 buf_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2127 codec_mode
= BUZ_MODE_MOTION_COMPRESS
;
2130 if (buf
->type
!= buf_type
) {
2132 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2133 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2135 goto qbuf_unlock_and_return
;
2138 res
= zoran_jpg_queue_frame(fh
, buf
->index
, codec_mode
);
2140 goto qbuf_unlock_and_return
;
2141 if (zr
->codec_mode
== BUZ_MODE_IDLE
&&
2142 fh
->buffers
.active
== ZORAN_LOCKED
)
2143 zr36057_enable_jpg(zr
, codec_mode
);
2149 "%s: VIDIOC_QBUF - unsupported type %d\n",
2150 ZR_DEVNAME(zr
), buf
->type
);
2154 qbuf_unlock_and_return
:
2155 mutex_unlock(&zr
->resource_lock
);
2160 static int zoran_dqbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2162 struct zoran_fh
*fh
= __fh
;
2163 struct zoran
*zr
= fh
->zr
;
2164 int res
= 0, buf_type
, num
= -1; /* compiler borks here (?) */
2166 mutex_lock(&zr
->resource_lock
);
2168 switch (fh
->map_mode
) {
2169 case ZORAN_MAP_MODE_RAW
:
2170 if (buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2172 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2173 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2175 goto dqbuf_unlock_and_return
;
2178 num
= zr
->v4l_pend
[zr
->v4l_sync_tail
& V4L_MASK_FRAME
];
2179 if (file
->f_flags
& O_NONBLOCK
&&
2180 zr
->v4l_buffers
.buffer
[num
].state
!= BUZ_STATE_DONE
) {
2182 goto dqbuf_unlock_and_return
;
2184 res
= v4l_sync(fh
, num
);
2186 goto dqbuf_unlock_and_return
;
2187 zr
->v4l_sync_tail
++;
2188 res
= zoran_v4l2_buffer_status(fh
, buf
, num
);
2191 case ZORAN_MAP_MODE_JPG_REC
:
2192 case ZORAN_MAP_MODE_JPG_PLAY
:
2194 struct zoran_sync bs
;
2196 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
)
2197 buf_type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2199 buf_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2201 if (buf
->type
!= buf_type
) {
2203 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2204 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2206 goto dqbuf_unlock_and_return
;
2209 num
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
2211 if (file
->f_flags
& O_NONBLOCK
&&
2212 zr
->jpg_buffers
.buffer
[num
].state
!= BUZ_STATE_DONE
) {
2214 goto dqbuf_unlock_and_return
;
2216 bs
.frame
= 0; /* suppress compiler warning */
2217 res
= jpg_sync(fh
, &bs
);
2219 goto dqbuf_unlock_and_return
;
2220 res
= zoran_v4l2_buffer_status(fh
, buf
, bs
.frame
);
2226 "%s: VIDIOC_DQBUF - unsupported type %d\n",
2227 ZR_DEVNAME(zr
), buf
->type
);
2231 dqbuf_unlock_and_return
:
2232 mutex_unlock(&zr
->resource_lock
);
2237 static int zoran_streamon(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
2239 struct zoran_fh
*fh
= __fh
;
2240 struct zoran
*zr
= fh
->zr
;
2243 mutex_lock(&zr
->resource_lock
);
2245 switch (fh
->map_mode
) {
2246 case ZORAN_MAP_MODE_RAW
: /* raw capture */
2247 if (zr
->v4l_buffers
.active
!= ZORAN_ACTIVE
||
2248 fh
->buffers
.active
!= ZORAN_ACTIVE
) {
2250 goto strmon_unlock_and_return
;
2253 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_LOCKED
;
2254 zr
->v4l_settings
= fh
->v4l_settings
;
2256 zr
->v4l_sync_tail
= zr
->v4l_pend_tail
;
2257 if (!zr
->v4l_memgrab_active
&&
2258 zr
->v4l_pend_head
!= zr
->v4l_pend_tail
) {
2259 zr36057_set_memgrab(zr
, 1);
2263 case ZORAN_MAP_MODE_JPG_REC
:
2264 case ZORAN_MAP_MODE_JPG_PLAY
:
2265 /* what is the codec mode right now? */
2266 if (zr
->jpg_buffers
.active
!= ZORAN_ACTIVE
||
2267 fh
->buffers
.active
!= ZORAN_ACTIVE
) {
2269 goto strmon_unlock_and_return
;
2272 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_LOCKED
;
2274 if (zr
->jpg_que_head
!= zr
->jpg_que_tail
) {
2275 /* Start the jpeg codec when the first frame is queued */
2283 "%s: VIDIOC_STREAMON - invalid map mode %d\n",
2284 ZR_DEVNAME(zr
), fh
->map_mode
);
2288 strmon_unlock_and_return
:
2289 mutex_unlock(&zr
->resource_lock
);
2294 static int zoran_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
2296 struct zoran_fh
*fh
= __fh
;
2297 struct zoran
*zr
= fh
->zr
;
2299 unsigned long flags
;
2301 mutex_lock(&zr
->resource_lock
);
2303 switch (fh
->map_mode
) {
2304 case ZORAN_MAP_MODE_RAW
: /* raw capture */
2305 if (fh
->buffers
.active
== ZORAN_FREE
&&
2306 zr
->v4l_buffers
.active
!= ZORAN_FREE
) {
2307 res
= -EPERM
; /* stay off other's settings! */
2308 goto strmoff_unlock_and_return
;
2310 if (zr
->v4l_buffers
.active
== ZORAN_FREE
)
2311 goto strmoff_unlock_and_return
;
2313 spin_lock_irqsave(&zr
->spinlock
, flags
);
2314 /* unload capture */
2315 if (zr
->v4l_memgrab_active
) {
2317 zr36057_set_memgrab(zr
, 0);
2320 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++)
2321 zr
->v4l_buffers
.buffer
[i
].state
= BUZ_STATE_USER
;
2322 fh
->buffers
= zr
->v4l_buffers
;
2324 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2326 zr
->v4l_grab_seq
= 0;
2327 zr
->v4l_pend_head
= zr
->v4l_pend_tail
= 0;
2328 zr
->v4l_sync_tail
= 0;
2330 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2334 case ZORAN_MAP_MODE_JPG_REC
:
2335 case ZORAN_MAP_MODE_JPG_PLAY
:
2336 if (fh
->buffers
.active
== ZORAN_FREE
&&
2337 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
2338 res
= -EPERM
; /* stay off other's settings! */
2339 goto strmoff_unlock_and_return
;
2341 if (zr
->jpg_buffers
.active
== ZORAN_FREE
)
2342 goto strmoff_unlock_and_return
;
2344 res
= jpg_qbuf(fh
, -1,
2345 (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
) ?
2346 BUZ_MODE_MOTION_COMPRESS
:
2347 BUZ_MODE_MOTION_DECOMPRESS
);
2349 goto strmoff_unlock_and_return
;
2353 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
2354 ZR_DEVNAME(zr
), fh
->map_mode
);
2358 strmoff_unlock_and_return
:
2359 mutex_unlock(&zr
->resource_lock
);
2364 static int zoran_queryctrl(struct file
*file
, void *__fh
,
2365 struct v4l2_queryctrl
*ctrl
)
2367 struct zoran_fh
*fh
= __fh
;
2368 struct zoran
*zr
= fh
->zr
;
2370 /* we only support hue/saturation/contrast/brightness */
2371 if (ctrl
->id
< V4L2_CID_BRIGHTNESS
||
2372 ctrl
->id
> V4L2_CID_HUE
)
2375 decoder_call(zr
, core
, queryctrl
, ctrl
);
2380 static int zoran_g_ctrl(struct file
*file
, void *__fh
, struct v4l2_control
*ctrl
)
2382 struct zoran_fh
*fh
= __fh
;
2383 struct zoran
*zr
= fh
->zr
;
2385 /* we only support hue/saturation/contrast/brightness */
2386 if (ctrl
->id
< V4L2_CID_BRIGHTNESS
||
2387 ctrl
->id
> V4L2_CID_HUE
)
2390 mutex_lock(&zr
->resource_lock
);
2391 decoder_call(zr
, core
, g_ctrl
, ctrl
);
2392 mutex_unlock(&zr
->resource_lock
);
2397 static int zoran_s_ctrl(struct file
*file
, void *__fh
, struct v4l2_control
*ctrl
)
2399 struct zoran_fh
*fh
= __fh
;
2400 struct zoran
*zr
= fh
->zr
;
2402 /* we only support hue/saturation/contrast/brightness */
2403 if (ctrl
->id
< V4L2_CID_BRIGHTNESS
||
2404 ctrl
->id
> V4L2_CID_HUE
)
2407 mutex_lock(&zr
->resource_lock
);
2408 decoder_call(zr
, core
, s_ctrl
, ctrl
);
2409 mutex_unlock(&zr
->resource_lock
);
2414 static int zoran_g_std(struct file
*file
, void *__fh
, v4l2_std_id
*std
)
2416 struct zoran_fh
*fh
= __fh
;
2417 struct zoran
*zr
= fh
->zr
;
2419 mutex_lock(&zr
->resource_lock
);
2421 mutex_unlock(&zr
->resource_lock
);
2425 static int zoran_s_std(struct file
*file
, void *__fh
, v4l2_std_id
*std
)
2427 struct zoran_fh
*fh
= __fh
;
2428 struct zoran
*zr
= fh
->zr
;
2431 mutex_lock(&zr
->resource_lock
);
2432 res
= zoran_set_norm(zr
, *std
);
2434 goto sstd_unlock_and_return
;
2436 res
= wait_grab_pending(zr
);
2437 sstd_unlock_and_return
:
2438 mutex_unlock(&zr
->resource_lock
);
2442 static int zoran_enum_input(struct file
*file
, void *__fh
,
2443 struct v4l2_input
*inp
)
2445 struct zoran_fh
*fh
= __fh
;
2446 struct zoran
*zr
= fh
->zr
;
2448 if (inp
->index
>= zr
->card
.inputs
)
2451 strncpy(inp
->name
, zr
->card
.input
[inp
->index
].name
,
2452 sizeof(inp
->name
) - 1);
2453 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
2454 inp
->std
= V4L2_STD_ALL
;
2456 /* Get status of video decoder */
2457 mutex_lock(&zr
->resource_lock
);
2458 decoder_call(zr
, video
, g_input_status
, &inp
->status
);
2459 mutex_unlock(&zr
->resource_lock
);
2463 static int zoran_g_input(struct file
*file
, void *__fh
, unsigned int *input
)
2465 struct zoran_fh
*fh
= __fh
;
2466 struct zoran
*zr
= fh
->zr
;
2468 mutex_lock(&zr
->resource_lock
);
2470 mutex_unlock(&zr
->resource_lock
);
2475 static int zoran_s_input(struct file
*file
, void *__fh
, unsigned int input
)
2477 struct zoran_fh
*fh
= __fh
;
2478 struct zoran
*zr
= fh
->zr
;
2481 mutex_lock(&zr
->resource_lock
);
2482 res
= zoran_set_input(zr
, input
);
2484 goto sinput_unlock_and_return
;
2486 /* Make sure the changes come into effect */
2487 res
= wait_grab_pending(zr
);
2488 sinput_unlock_and_return
:
2489 mutex_unlock(&zr
->resource_lock
);
2493 static int zoran_enum_output(struct file
*file
, void *__fh
,
2494 struct v4l2_output
*outp
)
2496 if (outp
->index
!= 0)
2500 outp
->type
= V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY
;
2501 strncpy(outp
->name
, "Autodetect", sizeof(outp
->name
)-1);
2506 static int zoran_g_output(struct file
*file
, void *__fh
, unsigned int *output
)
2513 static int zoran_s_output(struct file
*file
, void *__fh
, unsigned int output
)
2521 /* cropping (sub-frame capture) */
2522 static int zoran_cropcap(struct file
*file
, void *__fh
,
2523 struct v4l2_cropcap
*cropcap
)
2525 struct zoran_fh
*fh
= __fh
;
2526 struct zoran
*zr
= fh
->zr
;
2527 int type
= cropcap
->type
, res
= 0;
2529 memset(cropcap
, 0, sizeof(*cropcap
));
2530 cropcap
->type
= type
;
2532 mutex_lock(&zr
->resource_lock
);
2534 if (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2535 (cropcap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2536 fh
->map_mode
== ZORAN_MAP_MODE_RAW
)) {
2538 "%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",
2541 goto cropcap_unlock_and_return
;
2544 cropcap
->bounds
.top
= cropcap
->bounds
.left
= 0;
2545 cropcap
->bounds
.width
= BUZ_MAX_WIDTH
;
2546 cropcap
->bounds
.height
= BUZ_MAX_HEIGHT
;
2547 cropcap
->defrect
.top
= cropcap
->defrect
.left
= 0;
2548 cropcap
->defrect
.width
= BUZ_MIN_WIDTH
;
2549 cropcap
->defrect
.height
= BUZ_MIN_HEIGHT
;
2550 cropcap_unlock_and_return
:
2551 mutex_unlock(&zr
->resource_lock
);
2555 static int zoran_g_crop(struct file
*file
, void *__fh
, struct v4l2_crop
*crop
)
2557 struct zoran_fh
*fh
= __fh
;
2558 struct zoran
*zr
= fh
->zr
;
2559 int type
= crop
->type
, res
= 0;
2561 memset(crop
, 0, sizeof(*crop
));
2564 mutex_lock(&zr
->resource_lock
);
2566 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2567 (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2568 fh
->map_mode
== ZORAN_MAP_MODE_RAW
)) {
2571 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2574 goto gcrop_unlock_and_return
;
2577 crop
->c
.top
= fh
->jpg_settings
.img_y
;
2578 crop
->c
.left
= fh
->jpg_settings
.img_x
;
2579 crop
->c
.width
= fh
->jpg_settings
.img_width
;
2580 crop
->c
.height
= fh
->jpg_settings
.img_height
;
2582 gcrop_unlock_and_return
:
2583 mutex_unlock(&zr
->resource_lock
);
2588 static int zoran_s_crop(struct file
*file
, void *__fh
, struct v4l2_crop
*crop
)
2590 struct zoran_fh
*fh
= __fh
;
2591 struct zoran
*zr
= fh
->zr
;
2593 struct zoran_jpg_settings settings
;
2595 settings
= fh
->jpg_settings
;
2597 mutex_lock(&zr
->resource_lock
);
2599 if (fh
->buffers
.allocated
) {
2601 "%s: VIDIOC_S_CROP - cannot change settings while active\n",
2604 goto scrop_unlock_and_return
;
2607 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2608 (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2609 fh
->map_mode
== ZORAN_MAP_MODE_RAW
)) {
2611 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2614 goto scrop_unlock_and_return
;
2617 /* move into a form that we understand */
2618 settings
.img_x
= crop
->c
.left
;
2619 settings
.img_y
= crop
->c
.top
;
2620 settings
.img_width
= crop
->c
.width
;
2621 settings
.img_height
= crop
->c
.height
;
2623 /* check validity */
2624 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
2626 goto scrop_unlock_and_return
;
2629 fh
->jpg_settings
= settings
;
2631 scrop_unlock_and_return
:
2632 mutex_unlock(&zr
->resource_lock
);
2636 static int zoran_g_jpegcomp(struct file
*file
, void *__fh
,
2637 struct v4l2_jpegcompression
*params
)
2639 struct zoran_fh
*fh
= __fh
;
2640 struct zoran
*zr
= fh
->zr
;
2641 memset(params
, 0, sizeof(*params
));
2643 mutex_lock(&zr
->resource_lock
);
2645 params
->quality
= fh
->jpg_settings
.jpg_comp
.quality
;
2646 params
->APPn
= fh
->jpg_settings
.jpg_comp
.APPn
;
2647 memcpy(params
->APP_data
,
2648 fh
->jpg_settings
.jpg_comp
.APP_data
,
2649 fh
->jpg_settings
.jpg_comp
.APP_len
);
2650 params
->APP_len
= fh
->jpg_settings
.jpg_comp
.APP_len
;
2651 memcpy(params
->COM_data
,
2652 fh
->jpg_settings
.jpg_comp
.COM_data
,
2653 fh
->jpg_settings
.jpg_comp
.COM_len
);
2654 params
->COM_len
= fh
->jpg_settings
.jpg_comp
.COM_len
;
2655 params
->jpeg_markers
=
2656 fh
->jpg_settings
.jpg_comp
.jpeg_markers
;
2658 mutex_unlock(&zr
->resource_lock
);
2663 static int zoran_s_jpegcomp(struct file
*file
, void *__fh
,
2664 struct v4l2_jpegcompression
*params
)
2666 struct zoran_fh
*fh
= __fh
;
2667 struct zoran
*zr
= fh
->zr
;
2669 struct zoran_jpg_settings settings
;
2671 settings
= fh
->jpg_settings
;
2673 settings
.jpg_comp
= *params
;
2675 mutex_lock(&zr
->resource_lock
);
2677 if (fh
->buffers
.active
!= ZORAN_FREE
) {
2678 dprintk(1, KERN_WARNING
2679 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
2682 goto sjpegc_unlock_and_return
;
2685 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
2687 goto sjpegc_unlock_and_return
;
2688 if (!fh
->buffers
.allocated
)
2689 fh
->buffers
.buffer_size
=
2690 zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
2691 fh
->jpg_settings
.jpg_comp
= *params
= settings
.jpg_comp
;
2692 sjpegc_unlock_and_return
:
2693 mutex_unlock(&zr
->resource_lock
);
2699 zoran_poll (struct file
*file
,
2702 struct zoran_fh
*fh
= file
->private_data
;
2703 struct zoran
*zr
= fh
->zr
;
2705 unsigned long flags
;
2707 /* we should check whether buffers are ready to be synced on
2708 * (w/o waits - O_NONBLOCK) here
2709 * if ready for read (sync), return POLLIN|POLLRDNORM,
2710 * if ready for write (sync), return POLLOUT|POLLWRNORM,
2711 * if error, return POLLERR,
2712 * if no buffers queued or so, return POLLNVAL
2715 mutex_lock(&zr
->resource_lock
);
2717 switch (fh
->map_mode
) {
2718 case ZORAN_MAP_MODE_RAW
:
2719 poll_wait(file
, &zr
->v4l_capq
, wait
);
2720 frame
= zr
->v4l_pend
[zr
->v4l_sync_tail
& V4L_MASK_FRAME
];
2722 spin_lock_irqsave(&zr
->spinlock
, flags
);
2725 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
2726 ZR_DEVNAME(zr
), __func__
,
2727 "FAL"[fh
->buffers
.active
], zr
->v4l_sync_tail
,
2728 "UPMD"[zr
->v4l_buffers
.buffer
[frame
].state
],
2729 zr
->v4l_pend_tail
, zr
->v4l_pend_head
);
2730 /* Process is the one capturing? */
2731 if (fh
->buffers
.active
!= ZORAN_FREE
&&
2732 /* Buffer ready to DQBUF? */
2733 zr
->v4l_buffers
.buffer
[frame
].state
== BUZ_STATE_DONE
)
2734 res
= POLLIN
| POLLRDNORM
;
2735 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2739 case ZORAN_MAP_MODE_JPG_REC
:
2740 case ZORAN_MAP_MODE_JPG_PLAY
:
2741 poll_wait(file
, &zr
->jpg_capq
, wait
);
2742 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
2744 spin_lock_irqsave(&zr
->spinlock
, flags
);
2747 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
2748 ZR_DEVNAME(zr
), __func__
,
2749 "FAL"[fh
->buffers
.active
], zr
->jpg_que_tail
,
2750 "UPMD"[zr
->jpg_buffers
.buffer
[frame
].state
],
2751 zr
->jpg_que_head
, zr
->jpg_dma_tail
, zr
->jpg_dma_head
);
2752 if (fh
->buffers
.active
!= ZORAN_FREE
&&
2753 zr
->jpg_buffers
.buffer
[frame
].state
== BUZ_STATE_DONE
) {
2754 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
)
2755 res
= POLLIN
| POLLRDNORM
;
2757 res
= POLLOUT
| POLLWRNORM
;
2759 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2766 "%s: %s - internal error, unknown map_mode=%d\n",
2767 ZR_DEVNAME(zr
), __func__
, fh
->map_mode
);
2771 mutex_unlock(&zr
->resource_lock
);
2778 * This maps the buffers to user space.
2780 * Depending on the state of fh->map_mode
2781 * the V4L or the MJPEG buffers are mapped
2782 * per buffer or all together
2784 * Note that we need to connect to some
2785 * unmap signal event to unmap the de-allocate
2786 * the buffer accordingly (zoran_vm_close())
2790 zoran_vm_open (struct vm_area_struct
*vma
)
2792 struct zoran_mapping
*map
= vma
->vm_private_data
;
2798 zoran_vm_close (struct vm_area_struct
*vma
)
2800 struct zoran_mapping
*map
= vma
->vm_private_data
;
2801 struct zoran_fh
*fh
= map
->file
->private_data
;
2802 struct zoran
*zr
= fh
->zr
;
2805 if (--map
->count
> 0)
2808 dprintk(3, KERN_INFO
"%s: %s - munmap(%s)\n", ZR_DEVNAME(zr
),
2809 __func__
, mode_name(fh
->map_mode
));
2811 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
2812 if (fh
->buffers
.buffer
[i
].map
== map
)
2813 fh
->buffers
.buffer
[i
].map
= NULL
;
2817 /* Any buffers still mapped? */
2818 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++)
2819 if (fh
->buffers
.buffer
[i
].map
)
2822 dprintk(3, KERN_INFO
"%s: %s - free %s buffers\n", ZR_DEVNAME(zr
),
2823 __func__
, mode_name(fh
->map_mode
));
2825 mutex_lock(&zr
->resource_lock
);
2827 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
2828 if (fh
->buffers
.active
!= ZORAN_FREE
) {
2829 unsigned long flags
;
2831 spin_lock_irqsave(&zr
->spinlock
, flags
);
2832 zr36057_set_memgrab(zr
, 0);
2833 zr
->v4l_buffers
.allocated
= 0;
2834 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2835 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2837 v4l_fbuffer_free(fh
);
2839 if (fh
->buffers
.active
!= ZORAN_FREE
) {
2840 jpg_qbuf(fh
, -1, zr
->codec_mode
);
2841 zr
->jpg_buffers
.allocated
= 0;
2842 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2844 jpg_fbuffer_free(fh
);
2847 mutex_unlock(&zr
->resource_lock
);
2850 static const struct vm_operations_struct zoran_vm_ops
= {
2851 .open
= zoran_vm_open
,
2852 .close
= zoran_vm_close
,
2856 zoran_mmap (struct file
*file
,
2857 struct vm_area_struct
*vma
)
2859 struct zoran_fh
*fh
= file
->private_data
;
2860 struct zoran
*zr
= fh
->zr
;
2861 unsigned long size
= (vma
->vm_end
- vma
->vm_start
);
2862 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
2864 unsigned long page
, start
= vma
->vm_start
, todo
, pos
, fraglen
;
2866 struct zoran_mapping
*map
;
2870 KERN_INFO
"%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
2871 ZR_DEVNAME(zr
), __func__
,
2872 mode_name(fh
->map_mode
), vma
->vm_start
, vma
->vm_end
, size
);
2874 if (!(vma
->vm_flags
& VM_SHARED
) || !(vma
->vm_flags
& VM_READ
) ||
2875 !(vma
->vm_flags
& VM_WRITE
)) {
2878 "%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n",
2879 ZR_DEVNAME(zr
), __func__
);
2883 mutex_lock(&zr
->resource_lock
);
2885 if (!fh
->buffers
.allocated
) {
2888 "%s: %s(%s) - buffers not yet allocated\n",
2889 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
));
2891 goto mmap_unlock_and_return
;
2894 first
= offset
/ fh
->buffers
.buffer_size
;
2895 last
= first
- 1 + size
/ fh
->buffers
.buffer_size
;
2896 if (offset
% fh
->buffers
.buffer_size
!= 0 ||
2897 size
% fh
->buffers
.buffer_size
!= 0 || first
< 0 ||
2898 last
< 0 || first
>= fh
->buffers
.num_buffers
||
2899 last
>= fh
->buffers
.buffer_size
) {
2902 "%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
2903 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
), offset
, size
,
2904 fh
->buffers
.buffer_size
,
2905 fh
->buffers
.num_buffers
);
2907 goto mmap_unlock_and_return
;
2910 /* Check if any buffers are already mapped */
2911 for (i
= first
; i
<= last
; i
++) {
2912 if (fh
->buffers
.buffer
[i
].map
) {
2915 "%s: %s(%s) - buffer %d already mapped\n",
2916 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
), i
);
2918 goto mmap_unlock_and_return
;
2922 /* map these buffers */
2923 map
= kmalloc(sizeof(struct zoran_mapping
), GFP_KERNEL
);
2926 goto mmap_unlock_and_return
;
2931 vma
->vm_ops
= &zoran_vm_ops
;
2932 vma
->vm_flags
|= VM_DONTEXPAND
;
2933 vma
->vm_private_data
= map
;
2935 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
2936 for (i
= first
; i
<= last
; i
++) {
2938 if (todo
> fh
->buffers
.buffer_size
)
2939 todo
= fh
->buffers
.buffer_size
;
2940 page
= fh
->buffers
.buffer
[i
].v4l
.fbuffer_phys
;
2941 if (remap_pfn_range(vma
, start
, page
>> PAGE_SHIFT
,
2942 todo
, PAGE_SHARED
)) {
2945 "%s: %s(V4L) - remap_pfn_range failed\n",
2946 ZR_DEVNAME(zr
), __func__
);
2948 goto mmap_unlock_and_return
;
2952 fh
->buffers
.buffer
[i
].map
= map
;
2957 for (i
= first
; i
<= last
; i
++) {
2959 j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
;
2962 (le32_to_cpu(fh
->buffers
.buffer
[i
].jpg
.
2963 frag_tab
[2 * j
+ 1]) & ~1) << 1;
2968 le32_to_cpu(fh
->buffers
.
2969 buffer
[i
].jpg
.frag_tab
[2 * j
]);
2970 /* should just be pos on i386 */
2971 page
= virt_to_phys(bus_to_virt(pos
))
2973 if (remap_pfn_range(vma
, start
, page
,
2974 todo
, PAGE_SHARED
)) {
2977 "%s: %s(V4L) - remap_pfn_range failed\n",
2978 ZR_DEVNAME(zr
), __func__
);
2980 goto mmap_unlock_and_return
;
2986 if (le32_to_cpu(fh
->buffers
.buffer
[i
].jpg
.
2987 frag_tab
[2 * j
+ 1]) & 1)
2988 break; /* was last fragment */
2990 fh
->buffers
.buffer
[i
].map
= map
;
2997 mmap_unlock_and_return
:
2998 mutex_unlock(&zr
->resource_lock
);
3003 static const struct v4l2_ioctl_ops zoran_ioctl_ops
= {
3004 .vidioc_querycap
= zoran_querycap
,
3005 .vidioc_cropcap
= zoran_cropcap
,
3006 .vidioc_s_crop
= zoran_s_crop
,
3007 .vidioc_g_crop
= zoran_g_crop
,
3008 .vidioc_enum_input
= zoran_enum_input
,
3009 .vidioc_g_input
= zoran_g_input
,
3010 .vidioc_s_input
= zoran_s_input
,
3011 .vidioc_enum_output
= zoran_enum_output
,
3012 .vidioc_g_output
= zoran_g_output
,
3013 .vidioc_s_output
= zoran_s_output
,
3014 .vidioc_g_fbuf
= zoran_g_fbuf
,
3015 .vidioc_s_fbuf
= zoran_s_fbuf
,
3016 .vidioc_g_std
= zoran_g_std
,
3017 .vidioc_s_std
= zoran_s_std
,
3018 .vidioc_g_jpegcomp
= zoran_g_jpegcomp
,
3019 .vidioc_s_jpegcomp
= zoran_s_jpegcomp
,
3020 .vidioc_overlay
= zoran_overlay
,
3021 .vidioc_reqbufs
= zoran_reqbufs
,
3022 .vidioc_querybuf
= zoran_querybuf
,
3023 .vidioc_qbuf
= zoran_qbuf
,
3024 .vidioc_dqbuf
= zoran_dqbuf
,
3025 .vidioc_streamon
= zoran_streamon
,
3026 .vidioc_streamoff
= zoran_streamoff
,
3027 .vidioc_enum_fmt_vid_cap
= zoran_enum_fmt_vid_cap
,
3028 .vidioc_enum_fmt_vid_out
= zoran_enum_fmt_vid_out
,
3029 .vidioc_enum_fmt_vid_overlay
= zoran_enum_fmt_vid_overlay
,
3030 .vidioc_g_fmt_vid_cap
= zoran_g_fmt_vid_cap
,
3031 .vidioc_g_fmt_vid_out
= zoran_g_fmt_vid_out
,
3032 .vidioc_g_fmt_vid_overlay
= zoran_g_fmt_vid_overlay
,
3033 .vidioc_s_fmt_vid_cap
= zoran_s_fmt_vid_cap
,
3034 .vidioc_s_fmt_vid_out
= zoran_s_fmt_vid_out
,
3035 .vidioc_s_fmt_vid_overlay
= zoran_s_fmt_vid_overlay
,
3036 .vidioc_try_fmt_vid_cap
= zoran_try_fmt_vid_cap
,
3037 .vidioc_try_fmt_vid_out
= zoran_try_fmt_vid_out
,
3038 .vidioc_try_fmt_vid_overlay
= zoran_try_fmt_vid_overlay
,
3039 .vidioc_queryctrl
= zoran_queryctrl
,
3040 .vidioc_s_ctrl
= zoran_s_ctrl
,
3041 .vidioc_g_ctrl
= zoran_g_ctrl
,
3044 /* please use zr->resource_lock consistently and kill this wrapper */
3045 static long zoran_ioctl(struct file
*file
, unsigned int cmd
,
3048 struct zoran_fh
*fh
= file
->private_data
;
3049 struct zoran
*zr
= fh
->zr
;
3052 mutex_lock(&zr
->other_lock
);
3053 ret
= video_ioctl2(file
, cmd
, arg
);
3054 mutex_unlock(&zr
->other_lock
);
3059 static const struct v4l2_file_operations zoran_fops
= {
3060 .owner
= THIS_MODULE
,
3062 .release
= zoran_close
,
3063 .unlocked_ioctl
= zoran_ioctl
,
3065 .write
= zoran_write
,
3070 struct video_device zoran_template __devinitdata
= {
3072 .fops
= &zoran_fops
,
3073 .ioctl_ops
= &zoran_ioctl_ops
,
3074 .release
= &zoran_vdev_release
,
3075 .tvnorms
= V4L2_STD_NTSC
| V4L2_STD_PAL
| V4L2_STD_SECAM
,