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.
43 #include <linux/init.h>
44 #include <linux/module.h>
45 #include <linux/delay.h>
46 #include <linux/slab.h>
47 #include <linux/pci.h>
48 #include <linux/vmalloc.h>
49 #include <linux/wait.h>
51 #include <linux/interrupt.h>
52 #include <linux/i2c.h>
53 #include <linux/i2c-algo-bit.h>
55 #include <linux/spinlock.h>
57 #include <linux/videodev2.h>
58 #include <media/v4l2-common.h>
59 #include <media/v4l2-ioctl.h>
60 #include <media/v4l2-event.h>
61 #include "videocodec.h"
63 #include <asm/byteorder.h>
65 #include <linux/uaccess.h>
66 #include <linux/proc_fs.h>
68 #include <linux/mutex.h>
70 #include "zoran_device.h"
71 #include "zoran_card.h"
74 const struct zoran_format zoran_formats
[] = {
76 .name
= "15-bit RGB LE",
77 .fourcc
= V4L2_PIX_FMT_RGB555
,
78 .colorspace
= V4L2_COLORSPACE_SRGB
,
80 .flags
= ZORAN_FORMAT_CAPTURE
|
82 .vfespfr
= ZR36057_VFESPFR_RGB555
|ZR36057_VFESPFR_ErrDif
|
83 ZR36057_VFESPFR_LittleEndian
,
85 .name
= "15-bit RGB BE",
86 .fourcc
= V4L2_PIX_FMT_RGB555X
,
87 .colorspace
= V4L2_COLORSPACE_SRGB
,
89 .flags
= ZORAN_FORMAT_CAPTURE
|
91 .vfespfr
= ZR36057_VFESPFR_RGB555
|ZR36057_VFESPFR_ErrDif
,
93 .name
= "16-bit RGB LE",
94 .fourcc
= V4L2_PIX_FMT_RGB565
,
95 .colorspace
= V4L2_COLORSPACE_SRGB
,
97 .flags
= ZORAN_FORMAT_CAPTURE
|
99 .vfespfr
= ZR36057_VFESPFR_RGB565
|ZR36057_VFESPFR_ErrDif
|
100 ZR36057_VFESPFR_LittleEndian
,
102 .name
= "16-bit RGB BE",
103 .fourcc
= V4L2_PIX_FMT_RGB565X
,
104 .colorspace
= V4L2_COLORSPACE_SRGB
,
106 .flags
= ZORAN_FORMAT_CAPTURE
|
107 ZORAN_FORMAT_OVERLAY
,
108 .vfespfr
= ZR36057_VFESPFR_RGB565
|ZR36057_VFESPFR_ErrDif
,
110 .name
= "24-bit RGB",
111 .fourcc
= V4L2_PIX_FMT_BGR24
,
112 .colorspace
= V4L2_COLORSPACE_SRGB
,
114 .flags
= ZORAN_FORMAT_CAPTURE
|
115 ZORAN_FORMAT_OVERLAY
,
116 .vfespfr
= ZR36057_VFESPFR_RGB888
|ZR36057_VFESPFR_Pack24
,
118 .name
= "32-bit RGB LE",
119 .fourcc
= V4L2_PIX_FMT_BGR32
,
120 .colorspace
= V4L2_COLORSPACE_SRGB
,
122 .flags
= ZORAN_FORMAT_CAPTURE
|
123 ZORAN_FORMAT_OVERLAY
,
124 .vfespfr
= ZR36057_VFESPFR_RGB888
|ZR36057_VFESPFR_LittleEndian
,
126 .name
= "32-bit RGB BE",
127 .fourcc
= V4L2_PIX_FMT_RGB32
,
128 .colorspace
= V4L2_COLORSPACE_SRGB
,
130 .flags
= ZORAN_FORMAT_CAPTURE
|
131 ZORAN_FORMAT_OVERLAY
,
132 .vfespfr
= ZR36057_VFESPFR_RGB888
,
134 .name
= "4:2:2, packed, YUYV",
135 .fourcc
= V4L2_PIX_FMT_YUYV
,
136 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
138 .flags
= ZORAN_FORMAT_CAPTURE
|
139 ZORAN_FORMAT_OVERLAY
,
140 .vfespfr
= ZR36057_VFESPFR_YUV422
,
142 .name
= "4:2:2, packed, UYVY",
143 .fourcc
= V4L2_PIX_FMT_UYVY
,
144 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
146 .flags
= ZORAN_FORMAT_CAPTURE
|
147 ZORAN_FORMAT_OVERLAY
,
148 .vfespfr
= ZR36057_VFESPFR_YUV422
|ZR36057_VFESPFR_LittleEndian
,
150 .name
= "Hardware-encoded Motion-JPEG",
151 .fourcc
= V4L2_PIX_FMT_MJPEG
,
152 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
154 .flags
= ZORAN_FORMAT_CAPTURE
|
155 ZORAN_FORMAT_PLAYBACK
|
156 ZORAN_FORMAT_COMPRESSED
,
159 #define NUM_FORMATS ARRAY_SIZE(zoran_formats)
161 /* small helper function for calculating buffersizes for v4l2
162 * we calculate the nearest higher power-of-two, which
163 * will be the recommended buffersize */
165 zoran_v4l2_calc_bufsize (struct zoran_jpg_settings
*settings
)
167 __u8 div
= settings
->VerDcm
* settings
->HorDcm
* settings
->TmpDcm
;
168 __u32 num
= (1024 * 512) / (div
);
177 if (result
> jpg_bufsize
)
184 /* forward references */
185 static void v4l_fbuffer_free(struct zoran_fh
*fh
);
186 static void jpg_fbuffer_free(struct zoran_fh
*fh
);
188 /* Set mapping mode */
189 static void map_mode_raw(struct zoran_fh
*fh
)
191 fh
->map_mode
= ZORAN_MAP_MODE_RAW
;
192 fh
->buffers
.buffer_size
= v4l_bufsize
;
193 fh
->buffers
.num_buffers
= v4l_nbufs
;
195 static void map_mode_jpg(struct zoran_fh
*fh
, int play
)
197 fh
->map_mode
= play
? ZORAN_MAP_MODE_JPG_PLAY
: ZORAN_MAP_MODE_JPG_REC
;
198 fh
->buffers
.buffer_size
= jpg_bufsize
;
199 fh
->buffers
.num_buffers
= jpg_nbufs
;
201 static inline const char *mode_name(enum zoran_map_mode mode
)
203 return mode
== ZORAN_MAP_MODE_RAW
? "V4L" : "JPG";
207 * Allocate the V4L grab buffers
209 * These have to be pysically contiguous.
212 static int v4l_fbuffer_alloc(struct zoran_fh
*fh
)
214 struct zoran
*zr
= fh
->zr
;
218 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
219 if (fh
->buffers
.buffer
[i
].v4l
.fbuffer
)
222 "%s: %s - buffer %d already allocated!?\n",
223 ZR_DEVNAME(zr
), __func__
, i
);
226 mem
= kmalloc(fh
->buffers
.buffer_size
,
227 GFP_KERNEL
| __GFP_NOWARN
);
231 "%s: %s - kmalloc for V4L buf %d failed\n",
232 ZR_DEVNAME(zr
), __func__
, i
);
233 v4l_fbuffer_free(fh
);
236 fh
->buffers
.buffer
[i
].v4l
.fbuffer
= mem
;
237 fh
->buffers
.buffer
[i
].v4l
.fbuffer_phys
= virt_to_phys(mem
);
238 fh
->buffers
.buffer
[i
].v4l
.fbuffer_bus
= virt_to_bus(mem
);
239 for (off
= 0; off
< fh
->buffers
.buffer_size
;
241 SetPageReserved(virt_to_page(mem
+ off
));
244 "%s: %s - V4L frame %d mem 0x%lx (bus: 0x%llx)\n",
245 ZR_DEVNAME(zr
), __func__
, i
, (unsigned long) mem
,
246 (unsigned long long)virt_to_bus(mem
));
249 fh
->buffers
.allocated
= 1;
254 /* free the V4L grab buffers */
255 static void v4l_fbuffer_free(struct zoran_fh
*fh
)
257 struct zoran
*zr
= fh
->zr
;
261 dprintk(4, KERN_INFO
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
263 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
264 if (!fh
->buffers
.buffer
[i
].v4l
.fbuffer
)
267 mem
= fh
->buffers
.buffer
[i
].v4l
.fbuffer
;
268 for (off
= 0; off
< fh
->buffers
.buffer_size
;
270 ClearPageReserved(virt_to_page(mem
+ off
));
271 kfree(fh
->buffers
.buffer
[i
].v4l
.fbuffer
);
272 fh
->buffers
.buffer
[i
].v4l
.fbuffer
= NULL
;
275 fh
->buffers
.allocated
= 0;
279 * Allocate the MJPEG grab buffers.
281 * If a Natoma chipset is present and this is a revision 1 zr36057,
282 * each MJPEG buffer needs to be physically contiguous.
283 * (RJ: This statement is from Dave Perks' original driver,
284 * I could never check it because I have a zr36067)
286 * RJ: The contents grab buffers needs never be accessed in the driver.
287 * Therefore there is no need to allocate them with vmalloc in order
288 * to get a contiguous virtual memory space.
289 * I don't understand why many other drivers first allocate them with
290 * vmalloc (which uses internally also get_zeroed_page, but delivers you
291 * virtual addresses) and then again have to make a lot of efforts
292 * to get the physical address.
295 * On big-endian architectures (such as ppc) some extra steps
296 * are needed. When reading and writing to the stat_com array
297 * and fragment buffers, the device expects to see little-
298 * endian values. The use of cpu_to_le32() and le32_to_cpu()
299 * in this function (and one or two others in zoran_device.c)
300 * ensure that these values are always stored in little-endian
301 * form, regardless of architecture. The zr36057 does Very Bad
302 * Things on big endian architectures if the stat_com array
303 * and fragment buffers are not little-endian.
306 static int jpg_fbuffer_alloc(struct zoran_fh
*fh
)
308 struct zoran
*zr
= fh
->zr
;
312 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
313 if (fh
->buffers
.buffer
[i
].jpg
.frag_tab
)
316 "%s: %s - buffer %d already allocated!?\n",
317 ZR_DEVNAME(zr
), __func__
, i
);
319 /* Allocate fragment table for this buffer */
321 mem
= (void *)get_zeroed_page(GFP_KERNEL
);
325 "%s: %s - get_zeroed_page (frag_tab) failed for buffer %d\n",
326 ZR_DEVNAME(zr
), __func__
, i
);
327 jpg_fbuffer_free(fh
);
330 fh
->buffers
.buffer
[i
].jpg
.frag_tab
= (__le32
*)mem
;
331 fh
->buffers
.buffer
[i
].jpg
.frag_tab_bus
= virt_to_bus(mem
);
333 if (fh
->buffers
.need_contiguous
) {
334 mem
= kmalloc(fh
->buffers
.buffer_size
, GFP_KERNEL
);
338 "%s: %s - kmalloc failed for buffer %d\n",
339 ZR_DEVNAME(zr
), __func__
, i
);
340 jpg_fbuffer_free(fh
);
343 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[0] =
344 cpu_to_le32(virt_to_bus(mem
));
345 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[1] =
346 cpu_to_le32((fh
->buffers
.buffer_size
>> 1) | 1);
347 for (off
= 0; off
< fh
->buffers
.buffer_size
; off
+= PAGE_SIZE
)
348 SetPageReserved(virt_to_page(mem
+ off
));
350 /* jpg_bufsize is already page aligned */
351 for (j
= 0; j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
; j
++) {
352 mem
= (void *)get_zeroed_page(GFP_KERNEL
);
356 "%s: %s - get_zeroed_page failed for buffer %d\n",
357 ZR_DEVNAME(zr
), __func__
, i
);
358 jpg_fbuffer_free(fh
);
362 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
] =
363 cpu_to_le32(virt_to_bus(mem
));
364 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
+ 1] =
365 cpu_to_le32((PAGE_SIZE
>> 2) << 1);
366 SetPageReserved(virt_to_page(mem
));
369 fh
->buffers
.buffer
[i
].jpg
.frag_tab
[2 * j
- 1] |= cpu_to_le32(1);
374 KERN_DEBUG
"%s: %s - %d KB allocated\n",
375 ZR_DEVNAME(zr
), __func__
,
376 (fh
->buffers
.num_buffers
* fh
->buffers
.buffer_size
) >> 10);
378 fh
->buffers
.allocated
= 1;
383 /* free the MJPEG grab buffers */
384 static void jpg_fbuffer_free(struct zoran_fh
*fh
)
386 struct zoran
*zr
= fh
->zr
;
390 struct zoran_buffer
*buffer
;
392 dprintk(4, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
394 for (i
= 0, buffer
= &fh
->buffers
.buffer
[0];
395 i
< fh
->buffers
.num_buffers
; i
++, buffer
++) {
396 if (!buffer
->jpg
.frag_tab
)
399 if (fh
->buffers
.need_contiguous
) {
400 frag_tab
= buffer
->jpg
.frag_tab
[0];
403 mem
= bus_to_virt(le32_to_cpu(frag_tab
));
404 for (off
= 0; off
< fh
->buffers
.buffer_size
; off
+= PAGE_SIZE
)
405 ClearPageReserved(virt_to_page(mem
+ off
));
407 buffer
->jpg
.frag_tab
[0] = 0;
408 buffer
->jpg
.frag_tab
[1] = 0;
411 for (j
= 0; j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
; j
++) {
412 frag_tab
= buffer
->jpg
.frag_tab
[2 * j
];
416 ClearPageReserved(virt_to_page(bus_to_virt(le32_to_cpu(frag_tab
))));
417 free_page((unsigned long)bus_to_virt(le32_to_cpu(frag_tab
)));
418 buffer
->jpg
.frag_tab
[2 * j
] = 0;
419 buffer
->jpg
.frag_tab
[2 * j
+ 1] = 0;
423 free_page((unsigned long)buffer
->jpg
.frag_tab
);
424 buffer
->jpg
.frag_tab
= NULL
;
427 fh
->buffers
.allocated
= 0;
431 * V4L Buffer grabbing
435 zoran_v4l_set_format (struct zoran_fh
*fh
,
438 const struct zoran_format
*format
)
440 struct zoran
*zr
= fh
->zr
;
443 /* Check size and format of the grab wanted */
445 if (height
< BUZ_MIN_HEIGHT
|| width
< BUZ_MIN_WIDTH
||
446 height
> BUZ_MAX_HEIGHT
|| width
> BUZ_MAX_WIDTH
) {
449 "%s: %s - wrong frame size (%dx%d)\n",
450 ZR_DEVNAME(zr
), __func__
, width
, height
);
454 bpp
= (format
->depth
+ 7) / 8;
456 /* Check against available buffer size */
457 if (height
* width
* bpp
> fh
->buffers
.buffer_size
) {
460 "%s: %s - video buffer size (%d kB) is too small\n",
461 ZR_DEVNAME(zr
), __func__
, fh
->buffers
.buffer_size
>> 10);
465 /* The video front end needs 4-byte alinged line sizes */
467 if ((bpp
== 2 && (width
& 1)) || (bpp
== 3 && (width
& 3))) {
470 "%s: %s - wrong frame alignment\n",
471 ZR_DEVNAME(zr
), __func__
);
475 fh
->v4l_settings
.width
= width
;
476 fh
->v4l_settings
.height
= height
;
477 fh
->v4l_settings
.format
= format
;
478 fh
->v4l_settings
.bytesperline
= bpp
* fh
->v4l_settings
.width
;
483 static int zoran_v4l_queue_frame(struct zoran_fh
*fh
, int num
)
485 struct zoran
*zr
= fh
->zr
;
489 if (!fh
->buffers
.allocated
) {
492 "%s: %s - buffers not yet allocated\n",
493 ZR_DEVNAME(zr
), __func__
);
497 /* No grabbing outside the buffer range! */
498 if (num
>= fh
->buffers
.num_buffers
|| num
< 0) {
501 "%s: %s - buffer %d is out of range\n",
502 ZR_DEVNAME(zr
), __func__
, num
);
506 spin_lock_irqsave(&zr
->spinlock
, flags
);
508 if (fh
->buffers
.active
== ZORAN_FREE
) {
509 if (zr
->v4l_buffers
.active
== ZORAN_FREE
) {
510 zr
->v4l_buffers
= fh
->buffers
;
511 fh
->buffers
.active
= ZORAN_ACTIVE
;
515 "%s: %s - another session is already capturing\n",
516 ZR_DEVNAME(zr
), __func__
);
521 /* make sure a grab isn't going on currently with this buffer */
523 switch (zr
->v4l_buffers
.buffer
[num
].state
) {
526 if (zr
->v4l_buffers
.active
== ZORAN_FREE
) {
527 fh
->buffers
.active
= ZORAN_FREE
;
528 zr
->v4l_buffers
.allocated
= 0;
530 res
= -EBUSY
; /* what are you doing? */
535 "%s: %s - queueing buffer %d in state DONE!?\n",
536 ZR_DEVNAME(zr
), __func__
, num
);
539 /* since there is at least one unused buffer there's room for at least
540 * one more pend[] entry */
541 zr
->v4l_pend
[zr
->v4l_pend_head
++ & V4L_MASK_FRAME
] = num
;
542 zr
->v4l_buffers
.buffer
[num
].state
= BUZ_STATE_PEND
;
543 zr
->v4l_buffers
.buffer
[num
].bs
.length
=
544 fh
->v4l_settings
.bytesperline
*
545 zr
->v4l_settings
.height
;
546 fh
->buffers
.buffer
[num
] = zr
->v4l_buffers
.buffer
[num
];
551 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
553 if (!res
&& zr
->v4l_buffers
.active
== ZORAN_FREE
)
554 zr
->v4l_buffers
.active
= fh
->buffers
.active
;
560 * Sync on a V4L buffer
563 static int v4l_sync(struct zoran_fh
*fh
, int frame
)
565 struct zoran
*zr
= fh
->zr
;
568 if (fh
->buffers
.active
== ZORAN_FREE
) {
571 "%s: %s - no grab active for this session\n",
572 ZR_DEVNAME(zr
), __func__
);
576 /* check passed-in frame number */
577 if (frame
>= fh
->buffers
.num_buffers
|| frame
< 0) {
579 KERN_ERR
"%s: %s - frame %d is invalid\n",
580 ZR_DEVNAME(zr
), __func__
, frame
);
584 /* Check if is buffer was queued at all */
585 if (zr
->v4l_buffers
.buffer
[frame
].state
== BUZ_STATE_USER
) {
588 "%s: %s - attempt to sync on a buffer which was not queued?\n",
589 ZR_DEVNAME(zr
), __func__
);
593 mutex_unlock(&zr
->lock
);
594 /* wait on this buffer to get ready */
595 if (!wait_event_interruptible_timeout(zr
->v4l_capq
,
596 (zr
->v4l_buffers
.buffer
[frame
].state
!= BUZ_STATE_PEND
), 10*HZ
)) {
597 mutex_lock(&zr
->lock
);
600 mutex_lock(&zr
->lock
);
601 if (signal_pending(current
))
604 /* buffer should now be in BUZ_STATE_DONE */
605 if (zr
->v4l_buffers
.buffer
[frame
].state
!= BUZ_STATE_DONE
)
607 KERN_ERR
"%s: %s - internal state error\n",
608 ZR_DEVNAME(zr
), __func__
);
610 zr
->v4l_buffers
.buffer
[frame
].state
= BUZ_STATE_USER
;
611 fh
->buffers
.buffer
[frame
] = zr
->v4l_buffers
.buffer
[frame
];
613 spin_lock_irqsave(&zr
->spinlock
, flags
);
615 /* Check if streaming capture has finished */
616 if (zr
->v4l_pend_tail
== zr
->v4l_pend_head
) {
617 zr36057_set_memgrab(zr
, 0);
618 if (zr
->v4l_buffers
.active
== ZORAN_ACTIVE
) {
619 fh
->buffers
.active
= zr
->v4l_buffers
.active
= ZORAN_FREE
;
620 zr
->v4l_buffers
.allocated
= 0;
624 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
630 * Queue a MJPEG buffer for capture/playback
633 static int zoran_jpg_queue_frame(struct zoran_fh
*fh
, int num
,
634 enum zoran_codec_mode mode
)
636 struct zoran
*zr
= fh
->zr
;
640 /* Check if buffers are allocated */
641 if (!fh
->buffers
.allocated
) {
644 "%s: %s - buffers not yet allocated\n",
645 ZR_DEVNAME(zr
), __func__
);
649 /* No grabbing outside the buffer range! */
650 if (num
>= fh
->buffers
.num_buffers
|| num
< 0) {
653 "%s: %s - buffer %d out of range\n",
654 ZR_DEVNAME(zr
), __func__
, num
);
658 /* what is the codec mode right now? */
659 if (zr
->codec_mode
== BUZ_MODE_IDLE
) {
660 zr
->jpg_settings
= fh
->jpg_settings
;
661 } else if (zr
->codec_mode
!= mode
) {
662 /* wrong codec mode active - invalid */
665 "%s: %s - codec in wrong mode\n",
666 ZR_DEVNAME(zr
), __func__
);
670 if (fh
->buffers
.active
== ZORAN_FREE
) {
671 if (zr
->jpg_buffers
.active
== ZORAN_FREE
) {
672 zr
->jpg_buffers
= fh
->buffers
;
673 fh
->buffers
.active
= ZORAN_ACTIVE
;
677 "%s: %s - another session is already capturing\n",
678 ZR_DEVNAME(zr
), __func__
);
683 if (!res
&& zr
->codec_mode
== BUZ_MODE_IDLE
) {
684 /* Ok load up the jpeg codec */
685 zr36057_enable_jpg(zr
, mode
);
688 spin_lock_irqsave(&zr
->spinlock
, flags
);
691 switch (zr
->jpg_buffers
.buffer
[num
].state
) {
695 "%s: %s - queing frame in BUZ_STATE_DONE state!?\n",
696 ZR_DEVNAME(zr
), __func__
);
699 /* since there is at least one unused buffer there's room for at
700 *least one more pend[] entry */
701 zr
->jpg_pend
[zr
->jpg_que_head
++ & BUZ_MASK_FRAME
] = num
;
702 zr
->jpg_buffers
.buffer
[num
].state
= BUZ_STATE_PEND
;
703 fh
->buffers
.buffer
[num
] = zr
->jpg_buffers
.buffer
[num
];
704 zoran_feed_stat_com(zr
);
709 if (zr
->jpg_buffers
.active
== ZORAN_FREE
) {
710 fh
->buffers
.active
= ZORAN_FREE
;
711 zr
->jpg_buffers
.allocated
= 0;
713 res
= -EBUSY
; /* what are you doing? */
718 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
720 if (!res
&& zr
->jpg_buffers
.active
== ZORAN_FREE
)
721 zr
->jpg_buffers
.active
= fh
->buffers
.active
;
726 static int jpg_qbuf(struct zoran_fh
*fh
, int frame
, enum zoran_codec_mode mode
)
728 struct zoran
*zr
= fh
->zr
;
731 /* Does the user want to stop streaming? */
733 if (zr
->codec_mode
== mode
) {
734 if (fh
->buffers
.active
== ZORAN_FREE
) {
737 "%s: %s(-1) - session not active\n",
738 ZR_DEVNAME(zr
), __func__
);
741 fh
->buffers
.active
= zr
->jpg_buffers
.active
= ZORAN_FREE
;
742 zr
->jpg_buffers
.allocated
= 0;
743 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
748 "%s: %s - stop streaming but not in streaming mode\n",
749 ZR_DEVNAME(zr
), __func__
);
754 if ((res
= zoran_jpg_queue_frame(fh
, frame
, mode
)))
757 /* Start the jpeg codec when the first frame is queued */
758 if (!res
&& zr
->jpg_que_head
== 1)
765 * Sync on a MJPEG buffer
768 static int jpg_sync(struct zoran_fh
*fh
, struct zoran_sync
*bs
)
770 struct zoran
*zr
= fh
->zr
;
774 if (fh
->buffers
.active
== ZORAN_FREE
) {
777 "%s: %s - capture is not currently active\n",
778 ZR_DEVNAME(zr
), __func__
);
781 if (zr
->codec_mode
!= BUZ_MODE_MOTION_DECOMPRESS
&&
782 zr
->codec_mode
!= BUZ_MODE_MOTION_COMPRESS
) {
785 "%s: %s - codec not in streaming mode\n",
786 ZR_DEVNAME(zr
), __func__
);
789 mutex_unlock(&zr
->lock
);
790 if (!wait_event_interruptible_timeout(zr
->jpg_capq
,
791 (zr
->jpg_que_tail
!= zr
->jpg_dma_tail
||
792 zr
->jpg_dma_tail
== zr
->jpg_dma_head
),
796 btand(~ZR36057_JMC_Go_en
, ZR36057_JMC
);
798 zr
->codec
->control(zr
->codec
, CODEC_G_STATUS
,
800 mutex_lock(&zr
->lock
);
803 "%s: %s - timeout: codec isr=0x%02x\n",
804 ZR_DEVNAME(zr
), __func__
, isr
);
809 mutex_lock(&zr
->lock
);
810 if (signal_pending(current
))
813 spin_lock_irqsave(&zr
->spinlock
, flags
);
815 if (zr
->jpg_dma_tail
!= zr
->jpg_dma_head
)
816 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
++ & BUZ_MASK_FRAME
];
818 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
820 /* buffer should now be in BUZ_STATE_DONE */
821 if (zr
->jpg_buffers
.buffer
[frame
].state
!= BUZ_STATE_DONE
)
823 KERN_ERR
"%s: %s - internal state error\n",
824 ZR_DEVNAME(zr
), __func__
);
826 *bs
= zr
->jpg_buffers
.buffer
[frame
].bs
;
828 zr
->jpg_buffers
.buffer
[frame
].state
= BUZ_STATE_USER
;
829 fh
->buffers
.buffer
[frame
] = zr
->jpg_buffers
.buffer
[frame
];
831 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
836 static void zoran_open_init_session(struct zoran_fh
*fh
)
839 struct zoran
*zr
= fh
->zr
;
841 /* Per default, map the V4L Buffers */
844 /* take over the card's current settings */
845 fh
->overlay_settings
= zr
->overlay_settings
;
846 fh
->overlay_settings
.is_set
= 0;
847 fh
->overlay_settings
.format
= zr
->overlay_settings
.format
;
848 fh
->overlay_active
= ZORAN_FREE
;
851 fh
->v4l_settings
= zr
->v4l_settings
;
853 fh
->jpg_settings
= zr
->jpg_settings
;
856 memset(&fh
->buffers
, 0, sizeof(fh
->buffers
));
857 for (i
= 0; i
< MAX_FRAME
; i
++) {
858 fh
->buffers
.buffer
[i
].state
= BUZ_STATE_USER
; /* nothing going on */
859 fh
->buffers
.buffer
[i
].bs
.frame
= i
;
861 fh
->buffers
.allocated
= 0;
862 fh
->buffers
.active
= ZORAN_FREE
;
865 static void zoran_close_end_session(struct zoran_fh
*fh
)
867 struct zoran
*zr
= fh
->zr
;
870 if (fh
->overlay_active
!= ZORAN_FREE
) {
871 fh
->overlay_active
= zr
->overlay_active
= ZORAN_FREE
;
872 zr
->v4l_overlay_active
= 0;
873 if (!zr
->v4l_memgrab_active
)
874 zr36057_overlay(zr
, 0);
875 zr
->overlay_mask
= NULL
;
878 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
880 if (fh
->buffers
.active
!= ZORAN_FREE
) {
883 spin_lock_irqsave(&zr
->spinlock
, flags
);
884 zr36057_set_memgrab(zr
, 0);
885 zr
->v4l_buffers
.allocated
= 0;
886 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
887 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
891 if (fh
->buffers
.allocated
)
892 v4l_fbuffer_free(fh
);
895 if (fh
->buffers
.active
!= ZORAN_FREE
) {
896 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
897 zr
->jpg_buffers
.allocated
= 0;
898 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
902 if (fh
->buffers
.allocated
)
903 jpg_fbuffer_free(fh
);
908 * Open a zoran card. Right now the flags stuff is just playing
911 static int zoran_open(struct file
*file
)
913 struct zoran
*zr
= video_drvdata(file
);
915 int res
, first_open
= 0;
917 dprintk(2, KERN_INFO
"%s: %s(%s, pid=[%d]), users(-)=%d\n",
918 ZR_DEVNAME(zr
), __func__
, current
->comm
, task_pid_nr(current
), zr
->user
+ 1);
920 mutex_lock(&zr
->lock
);
922 if (zr
->user
>= 2048) {
923 dprintk(1, KERN_ERR
"%s: too many users (%d) on device\n",
924 ZR_DEVNAME(zr
), zr
->user
);
929 /* now, create the open()-specific file_ops struct */
930 fh
= kzalloc(sizeof(struct zoran_fh
), GFP_KERNEL
);
934 "%s: %s - allocation of zoran_fh failed\n",
935 ZR_DEVNAME(zr
), __func__
);
939 v4l2_fh_init(&fh
->fh
, video_devdata(file
));
941 /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
944 kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL
);
945 if (!fh
->overlay_mask
) {
948 "%s: %s - allocation of overlay_mask failed\n",
949 ZR_DEVNAME(zr
), __func__
);
957 /* default setup - TODO: look at flags */
958 if (first_open
) { /* First device open */
960 zoran_open_init_params(zr
);
961 zoran_init_hardware(zr
);
963 btor(ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
966 /* set file_ops stuff */
967 file
->private_data
= fh
;
969 zoran_open_init_session(fh
);
970 v4l2_fh_add(&fh
->fh
);
971 mutex_unlock(&zr
->lock
);
976 v4l2_fh_exit(&fh
->fh
);
979 mutex_unlock(&zr
->lock
);
981 dprintk(2, KERN_INFO
"%s: open failed (%d), users(-)=%d\n",
982 ZR_DEVNAME(zr
), res
, zr
->user
);
988 zoran_close(struct file
*file
)
990 struct zoran_fh
*fh
= file
->private_data
;
991 struct zoran
*zr
= fh
->zr
;
993 dprintk(2, KERN_INFO
"%s: %s(%s, pid=[%d]), users(+)=%d\n",
994 ZR_DEVNAME(zr
), __func__
, current
->comm
, task_pid_nr(current
), zr
->user
- 1);
996 /* kernel locks (fs/device.c), so don't do that ourselves
997 * (prevents deadlocks) */
998 mutex_lock(&zr
->lock
);
1000 zoran_close_end_session(fh
);
1002 if (zr
->user
-- == 1) { /* Last process */
1003 /* Clean up JPEG process */
1004 wake_up_interruptible(&zr
->jpg_capq
);
1005 zr36057_enable_jpg(zr
, BUZ_MODE_IDLE
);
1006 zr
->jpg_buffers
.allocated
= 0;
1007 zr
->jpg_buffers
.active
= ZORAN_FREE
;
1009 /* disable interrupts */
1010 btand(~ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
1012 if (zr36067_debug
> 1)
1013 print_interrupts(zr
);
1016 zr
->v4l_overlay_active
= 0;
1017 zr36057_overlay(zr
, 0);
1018 zr
->overlay_mask
= NULL
;
1021 wake_up_interruptible(&zr
->v4l_capq
);
1022 zr36057_set_memgrab(zr
, 0);
1023 zr
->v4l_buffers
.allocated
= 0;
1024 zr
->v4l_buffers
.active
= ZORAN_FREE
;
1025 zoran_set_pci_master(zr
, 0);
1027 if (!pass_through
) { /* Switch to color bar */
1028 decoder_call(zr
, video
, s_stream
, 0);
1029 encoder_call(zr
, video
, s_routing
, 2, 0, 0);
1032 mutex_unlock(&zr
->lock
);
1034 v4l2_fh_del(&fh
->fh
);
1035 v4l2_fh_exit(&fh
->fh
);
1036 kfree(fh
->overlay_mask
);
1039 dprintk(4, KERN_INFO
"%s: %s done\n", ZR_DEVNAME(zr
), __func__
);
1044 static int setup_fbuffer(struct zoran_fh
*fh
,
1046 const struct zoran_format
*fmt
,
1051 struct zoran
*zr
= fh
->zr
;
1053 /* (Ronald) v4l/v4l2 guidelines */
1054 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
1057 /* Don't allow frame buffer overlay if PCI or AGP is buggy, or on
1058 ALi Magik (that needs very low latency while the card needs a
1059 higher value always) */
1061 if (pci_pci_problems
& (PCIPCI_FAIL
| PCIAGP_FAIL
| PCIPCI_ALIMAGIK
))
1064 /* we need a bytesperline value, even if not given */
1066 bytesperline
= width
* ((fmt
->depth
+ 7) & ~7) / 8;
1069 if (zr
->overlay_active
) {
1070 /* dzjee... stupid users... don't even bother to turn off
1071 * overlay before changing the memory location...
1072 * normally, we would return errors here. However, one of
1073 * the tools that does this is... xawtv! and since xawtv
1074 * is used by +/- 99% of the users, we'd rather be user-
1075 * friendly and silently do as if nothing went wrong */
1078 "%s: %s - forced overlay turnoff because framebuffer changed\n",
1079 ZR_DEVNAME(zr
), __func__
);
1080 zr36057_overlay(zr
, 0);
1084 if (!(fmt
->flags
& ZORAN_FORMAT_OVERLAY
)) {
1087 "%s: %s - no valid overlay format given\n",
1088 ZR_DEVNAME(zr
), __func__
);
1091 if (height
<= 0 || width
<= 0 || bytesperline
<= 0) {
1094 "%s: %s - invalid height/width/bpl value (%d|%d|%d)\n",
1095 ZR_DEVNAME(zr
), __func__
, width
, height
, bytesperline
);
1098 if (bytesperline
& 3) {
1101 "%s: %s - bytesperline (%d) must be 4-byte aligned\n",
1102 ZR_DEVNAME(zr
), __func__
, bytesperline
);
1106 zr
->vbuf_base
= (void *) ((unsigned long) base
& ~3);
1107 zr
->vbuf_height
= height
;
1108 zr
->vbuf_width
= width
;
1109 zr
->vbuf_depth
= fmt
->depth
;
1110 zr
->overlay_settings
.format
= fmt
;
1111 zr
->vbuf_bytesperline
= bytesperline
;
1113 /* The user should set new window parameters */
1114 zr
->overlay_settings
.is_set
= 0;
1120 static int setup_window(struct zoran_fh
*fh
,
1125 struct v4l2_clip __user
*clips
,
1126 unsigned int clipcount
,
1127 void __user
*bitmap
)
1129 struct zoran
*zr
= fh
->zr
;
1130 struct v4l2_clip
*vcp
= NULL
;
1134 if (!zr
->vbuf_base
) {
1137 "%s: %s - frame buffer has to be set first\n",
1138 ZR_DEVNAME(zr
), __func__
);
1142 if (!fh
->overlay_settings
.format
) {
1145 "%s: %s - no overlay format set\n",
1146 ZR_DEVNAME(zr
), __func__
);
1150 if (clipcount
> 2048) {
1153 "%s: %s - invalid clipcount\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
) {
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
| V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
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_SECAM
)
1446 zr
->timing
= zr
->card
.tvn
[2];
1447 else if (norm
& V4L2_STD_NTSC
)
1448 zr
->timing
= zr
->card
.tvn
[1];
1450 zr
->timing
= zr
->card
.tvn
[0];
1452 /* We switch overlay off and on since a change in the
1453 * norm needs different VFE settings */
1454 on
= zr
->overlay_active
&& !zr
->v4l_memgrab_active
;
1456 zr36057_overlay(zr
, 0);
1458 decoder_call(zr
, video
, s_std
, norm
);
1459 encoder_call(zr
, video
, s_std_output
, norm
);
1462 zr36057_overlay(zr
, 1);
1464 /* Make sure the changes come into effect */
1471 zoran_set_input (struct zoran
*zr
,
1474 if (input
== zr
->input
) {
1478 if (zr
->v4l_buffers
.active
!= ZORAN_FREE
||
1479 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
1482 "%s: %s called while in playback/capture mode\n",
1483 ZR_DEVNAME(zr
), __func__
);
1487 if (input
< 0 || input
>= zr
->card
.inputs
) {
1490 "%s: %s - unsupported input %d\n",
1491 ZR_DEVNAME(zr
), __func__
, input
);
1497 decoder_call(zr
, video
, s_routing
,
1498 zr
->card
.input
[input
].muxsel
, 0, 0);
1507 static int zoran_querycap(struct file
*file
, void *__fh
, struct v4l2_capability
*cap
)
1509 struct zoran_fh
*fh
= __fh
;
1510 struct zoran
*zr
= fh
->zr
;
1512 strncpy(cap
->card
, ZR_DEVNAME(zr
), sizeof(cap
->card
)-1);
1513 strncpy(cap
->driver
, "zoran", sizeof(cap
->driver
)-1);
1514 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "PCI:%s",
1515 pci_name(zr
->pci_dev
));
1516 cap
->device_caps
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_CAPTURE
|
1517 V4L2_CAP_VIDEO_OUTPUT
| V4L2_CAP_VIDEO_OVERLAY
;
1518 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
1522 static int zoran_enum_fmt(struct zoran
*zr
, struct v4l2_fmtdesc
*fmt
, int flag
)
1524 unsigned int num
, i
;
1526 for (num
= i
= 0; i
< NUM_FORMATS
; i
++) {
1527 if (zoran_formats
[i
].flags
& flag
&& num
++ == fmt
->index
) {
1528 strncpy(fmt
->description
, zoran_formats
[i
].name
,
1529 sizeof(fmt
->description
) - 1);
1530 /* fmt struct pre-zeroed, so adding '\0' not needed */
1531 fmt
->pixelformat
= zoran_formats
[i
].fourcc
;
1532 if (zoran_formats
[i
].flags
& ZORAN_FORMAT_COMPRESSED
)
1533 fmt
->flags
|= V4L2_FMT_FLAG_COMPRESSED
;
1540 static int zoran_enum_fmt_vid_cap(struct file
*file
, void *__fh
,
1541 struct v4l2_fmtdesc
*f
)
1543 struct zoran_fh
*fh
= __fh
;
1544 struct zoran
*zr
= fh
->zr
;
1546 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_CAPTURE
);
1549 static int zoran_enum_fmt_vid_out(struct file
*file
, void *__fh
,
1550 struct v4l2_fmtdesc
*f
)
1552 struct zoran_fh
*fh
= __fh
;
1553 struct zoran
*zr
= fh
->zr
;
1555 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_PLAYBACK
);
1558 static int zoran_enum_fmt_vid_overlay(struct file
*file
, void *__fh
,
1559 struct v4l2_fmtdesc
*f
)
1561 struct zoran_fh
*fh
= __fh
;
1562 struct zoran
*zr
= fh
->zr
;
1564 return zoran_enum_fmt(zr
, f
, ZORAN_FORMAT_OVERLAY
);
1567 static int zoran_g_fmt_vid_out(struct file
*file
, void *__fh
,
1568 struct v4l2_format
*fmt
)
1570 struct zoran_fh
*fh
= __fh
;
1572 fmt
->fmt
.pix
.width
= fh
->jpg_settings
.img_width
/ fh
->jpg_settings
.HorDcm
;
1573 fmt
->fmt
.pix
.height
= fh
->jpg_settings
.img_height
* 2 /
1574 (fh
->jpg_settings
.VerDcm
* fh
->jpg_settings
.TmpDcm
);
1575 fmt
->fmt
.pix
.sizeimage
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
1576 fmt
->fmt
.pix
.pixelformat
= V4L2_PIX_FMT_MJPEG
;
1577 if (fh
->jpg_settings
.TmpDcm
== 1)
1578 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1579 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1581 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1582 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1583 fmt
->fmt
.pix
.bytesperline
= 0;
1584 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1589 static int zoran_g_fmt_vid_cap(struct file
*file
, void *__fh
,
1590 struct v4l2_format
*fmt
)
1592 struct zoran_fh
*fh
= __fh
;
1593 struct zoran
*zr
= fh
->zr
;
1595 if (fh
->map_mode
!= ZORAN_MAP_MODE_RAW
)
1596 return zoran_g_fmt_vid_out(file
, fh
, fmt
);
1598 fmt
->fmt
.pix
.width
= fh
->v4l_settings
.width
;
1599 fmt
->fmt
.pix
.height
= fh
->v4l_settings
.height
;
1600 fmt
->fmt
.pix
.sizeimage
= fh
->v4l_settings
.bytesperline
*
1601 fh
->v4l_settings
.height
;
1602 fmt
->fmt
.pix
.pixelformat
= fh
->v4l_settings
.format
->fourcc
;
1603 fmt
->fmt
.pix
.colorspace
= fh
->v4l_settings
.format
->colorspace
;
1604 fmt
->fmt
.pix
.bytesperline
= fh
->v4l_settings
.bytesperline
;
1605 if (BUZ_MAX_HEIGHT
< (fh
->v4l_settings
.height
* 2))
1606 fmt
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1608 fmt
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
1612 static int zoran_g_fmt_vid_overlay(struct file
*file
, void *__fh
,
1613 struct v4l2_format
*fmt
)
1615 struct zoran_fh
*fh
= __fh
;
1616 struct zoran
*zr
= fh
->zr
;
1618 fmt
->fmt
.win
.w
.left
= fh
->overlay_settings
.x
;
1619 fmt
->fmt
.win
.w
.top
= fh
->overlay_settings
.y
;
1620 fmt
->fmt
.win
.w
.width
= fh
->overlay_settings
.width
;
1621 fmt
->fmt
.win
.w
.height
= fh
->overlay_settings
.height
;
1622 if (fh
->overlay_settings
.width
* 2 > BUZ_MAX_HEIGHT
)
1623 fmt
->fmt
.win
.field
= V4L2_FIELD_INTERLACED
;
1625 fmt
->fmt
.win
.field
= V4L2_FIELD_TOP
;
1630 static int zoran_try_fmt_vid_overlay(struct file
*file
, void *__fh
,
1631 struct v4l2_format
*fmt
)
1633 struct zoran_fh
*fh
= __fh
;
1634 struct zoran
*zr
= fh
->zr
;
1636 if (fmt
->fmt
.win
.w
.width
> BUZ_MAX_WIDTH
)
1637 fmt
->fmt
.win
.w
.width
= BUZ_MAX_WIDTH
;
1638 if (fmt
->fmt
.win
.w
.width
< BUZ_MIN_WIDTH
)
1639 fmt
->fmt
.win
.w
.width
= BUZ_MIN_WIDTH
;
1640 if (fmt
->fmt
.win
.w
.height
> BUZ_MAX_HEIGHT
)
1641 fmt
->fmt
.win
.w
.height
= BUZ_MAX_HEIGHT
;
1642 if (fmt
->fmt
.win
.w
.height
< BUZ_MIN_HEIGHT
)
1643 fmt
->fmt
.win
.w
.height
= BUZ_MIN_HEIGHT
;
1648 static int zoran_try_fmt_vid_out(struct file
*file
, void *__fh
,
1649 struct v4l2_format
*fmt
)
1651 struct zoran_fh
*fh
= __fh
;
1652 struct zoran
*zr
= fh
->zr
;
1653 struct zoran_jpg_settings settings
;
1656 if (fmt
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
1659 settings
= fh
->jpg_settings
;
1661 /* we actually need to set 'real' parameters now */
1662 if ((fmt
->fmt
.pix
.height
* 2) > BUZ_MAX_HEIGHT
)
1663 settings
.TmpDcm
= 1;
1665 settings
.TmpDcm
= 2;
1666 settings
.decimation
= 0;
1667 if (fmt
->fmt
.pix
.height
<= fh
->jpg_settings
.img_height
/ 2)
1668 settings
.VerDcm
= 2;
1670 settings
.VerDcm
= 1;
1671 if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 4)
1672 settings
.HorDcm
= 4;
1673 else if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 2)
1674 settings
.HorDcm
= 2;
1676 settings
.HorDcm
= 1;
1677 if (settings
.TmpDcm
== 1)
1678 settings
.field_per_buff
= 2;
1680 settings
.field_per_buff
= 1;
1682 if (settings
.HorDcm
> 1) {
1683 settings
.img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
1684 settings
.img_width
= (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
1687 settings
.img_width
= BUZ_MAX_WIDTH
;
1691 res
= zoran_check_jpg_settings(zr
, &settings
, 1);
1695 /* tell the user what we actually did */
1696 fmt
->fmt
.pix
.width
= settings
.img_width
/ settings
.HorDcm
;
1697 fmt
->fmt
.pix
.height
= settings
.img_height
* 2 /
1698 (settings
.TmpDcm
* settings
.VerDcm
);
1699 if (settings
.TmpDcm
== 1)
1700 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1701 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1703 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1704 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1706 fmt
->fmt
.pix
.sizeimage
= zoran_v4l2_calc_bufsize(&settings
);
1707 fmt
->fmt
.pix
.bytesperline
= 0;
1708 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1712 static int zoran_try_fmt_vid_cap(struct file
*file
, void *__fh
,
1713 struct v4l2_format
*fmt
)
1715 struct zoran_fh
*fh
= __fh
;
1716 struct zoran
*zr
= fh
->zr
;
1720 if (fmt
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_MJPEG
)
1721 return zoran_try_fmt_vid_out(file
, fh
, fmt
);
1723 for (i
= 0; i
< NUM_FORMATS
; i
++)
1724 if (zoran_formats
[i
].fourcc
== fmt
->fmt
.pix
.pixelformat
)
1727 if (i
== NUM_FORMATS
)
1730 bpp
= DIV_ROUND_UP(zoran_formats
[i
].depth
, 8);
1731 v4l_bound_align_image(
1732 &fmt
->fmt
.pix
.width
, BUZ_MIN_WIDTH
, BUZ_MAX_WIDTH
, bpp
== 2 ? 1 : 2,
1733 &fmt
->fmt
.pix
.height
, BUZ_MIN_HEIGHT
, BUZ_MAX_HEIGHT
, 0, 0);
1737 static int zoran_s_fmt_vid_overlay(struct file
*file
, void *__fh
,
1738 struct v4l2_format
*fmt
)
1740 struct zoran_fh
*fh
= __fh
;
1743 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
1744 fmt
->fmt
.win
.w
.left
, fmt
->fmt
.win
.w
.top
,
1745 fmt
->fmt
.win
.w
.width
,
1746 fmt
->fmt
.win
.w
.height
,
1747 fmt
->fmt
.win
.clipcount
,
1748 fmt
->fmt
.win
.bitmap
);
1749 res
= setup_window(fh
, fmt
->fmt
.win
.w
.left
, fmt
->fmt
.win
.w
.top
,
1750 fmt
->fmt
.win
.w
.width
, fmt
->fmt
.win
.w
.height
,
1751 (struct v4l2_clip __user
*)fmt
->fmt
.win
.clips
,
1752 fmt
->fmt
.win
.clipcount
, fmt
->fmt
.win
.bitmap
);
1756 static int zoran_s_fmt_vid_out(struct file
*file
, void *__fh
,
1757 struct v4l2_format
*fmt
)
1759 struct zoran_fh
*fh
= __fh
;
1760 struct zoran
*zr
= fh
->zr
;
1761 __le32 printformat
= __cpu_to_le32(fmt
->fmt
.pix
.pixelformat
);
1762 struct zoran_jpg_settings settings
;
1765 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
1766 fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
,
1767 fmt
->fmt
.pix
.pixelformat
,
1768 (char *) &printformat
);
1769 if (fmt
->fmt
.pix
.pixelformat
!= V4L2_PIX_FMT_MJPEG
)
1772 if (fh
->buffers
.allocated
) {
1773 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - cannot change capture mode\n",
1779 settings
= fh
->jpg_settings
;
1781 /* we actually need to set 'real' parameters now */
1782 if (fmt
->fmt
.pix
.height
* 2 > BUZ_MAX_HEIGHT
)
1783 settings
.TmpDcm
= 1;
1785 settings
.TmpDcm
= 2;
1786 settings
.decimation
= 0;
1787 if (fmt
->fmt
.pix
.height
<= fh
->jpg_settings
.img_height
/ 2)
1788 settings
.VerDcm
= 2;
1790 settings
.VerDcm
= 1;
1791 if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 4)
1792 settings
.HorDcm
= 4;
1793 else if (fmt
->fmt
.pix
.width
<= fh
->jpg_settings
.img_width
/ 2)
1794 settings
.HorDcm
= 2;
1796 settings
.HorDcm
= 1;
1797 if (settings
.TmpDcm
== 1)
1798 settings
.field_per_buff
= 2;
1800 settings
.field_per_buff
= 1;
1802 if (settings
.HorDcm
> 1) {
1803 settings
.img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
1804 settings
.img_width
= (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
1807 settings
.img_width
= BUZ_MAX_WIDTH
;
1811 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
1815 /* it's ok, so set them */
1816 fh
->jpg_settings
= settings
;
1818 map_mode_jpg(fh
, fmt
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
);
1819 fh
->buffers
.buffer_size
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
1821 /* tell the user what we actually did */
1822 fmt
->fmt
.pix
.width
= settings
.img_width
/ settings
.HorDcm
;
1823 fmt
->fmt
.pix
.height
= settings
.img_height
* 2 /
1824 (settings
.TmpDcm
* settings
.VerDcm
);
1825 if (settings
.TmpDcm
== 1)
1826 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1827 V4L2_FIELD_SEQ_TB
: V4L2_FIELD_SEQ_BT
);
1829 fmt
->fmt
.pix
.field
= (fh
->jpg_settings
.odd_even
?
1830 V4L2_FIELD_TOP
: V4L2_FIELD_BOTTOM
);
1831 fmt
->fmt
.pix
.bytesperline
= 0;
1832 fmt
->fmt
.pix
.sizeimage
= fh
->buffers
.buffer_size
;
1833 fmt
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1837 static int zoran_s_fmt_vid_cap(struct file
*file
, void *__fh
,
1838 struct v4l2_format
*fmt
)
1840 struct zoran_fh
*fh
= __fh
;
1841 struct zoran
*zr
= fh
->zr
;
1845 if (fmt
->fmt
.pix
.pixelformat
== V4L2_PIX_FMT_MJPEG
)
1846 return zoran_s_fmt_vid_out(file
, fh
, fmt
);
1848 for (i
= 0; i
< NUM_FORMATS
; i
++)
1849 if (fmt
->fmt
.pix
.pixelformat
== zoran_formats
[i
].fourcc
)
1851 if (i
== NUM_FORMATS
) {
1852 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",
1853 ZR_DEVNAME(zr
), fmt
->fmt
.pix
.pixelformat
);
1857 if ((fh
->map_mode
!= ZORAN_MAP_MODE_RAW
&& fh
->buffers
.allocated
) ||
1858 fh
->buffers
.active
!= ZORAN_FREE
) {
1859 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FMT - cannot change capture mode\n",
1864 if (fmt
->fmt
.pix
.height
> BUZ_MAX_HEIGHT
)
1865 fmt
->fmt
.pix
.height
= BUZ_MAX_HEIGHT
;
1866 if (fmt
->fmt
.pix
.width
> BUZ_MAX_WIDTH
)
1867 fmt
->fmt
.pix
.width
= BUZ_MAX_WIDTH
;
1871 res
= zoran_v4l_set_format(fh
, fmt
->fmt
.pix
.width
, fmt
->fmt
.pix
.height
,
1876 /* tell the user the results/missing stuff */
1877 fmt
->fmt
.pix
.bytesperline
= fh
->v4l_settings
.bytesperline
;
1878 fmt
->fmt
.pix
.sizeimage
= fh
->v4l_settings
.height
* fh
->v4l_settings
.bytesperline
;
1879 fmt
->fmt
.pix
.colorspace
= fh
->v4l_settings
.format
->colorspace
;
1880 if (BUZ_MAX_HEIGHT
< (fh
->v4l_settings
.height
* 2))
1881 fmt
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
1883 fmt
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
1887 static int zoran_g_fbuf(struct file
*file
, void *__fh
,
1888 struct v4l2_framebuffer
*fb
)
1890 struct zoran_fh
*fh
= __fh
;
1891 struct zoran
*zr
= fh
->zr
;
1893 memset(fb
, 0, sizeof(*fb
));
1894 fb
->base
= zr
->vbuf_base
;
1895 fb
->fmt
.width
= zr
->vbuf_width
;
1896 fb
->fmt
.height
= zr
->vbuf_height
;
1897 if (zr
->overlay_settings
.format
)
1898 fb
->fmt
.pixelformat
= fh
->overlay_settings
.format
->fourcc
;
1899 fb
->fmt
.bytesperline
= zr
->vbuf_bytesperline
;
1900 fb
->fmt
.colorspace
= V4L2_COLORSPACE_SRGB
;
1901 fb
->fmt
.field
= V4L2_FIELD_INTERLACED
;
1902 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
1907 static int zoran_s_fbuf(struct file
*file
, void *__fh
,
1908 const struct v4l2_framebuffer
*fb
)
1910 struct zoran_fh
*fh
= __fh
;
1911 struct zoran
*zr
= fh
->zr
;
1913 __le32 printformat
= __cpu_to_le32(fb
->fmt
.pixelformat
);
1915 for (i
= 0; i
< NUM_FORMATS
; i
++)
1916 if (zoran_formats
[i
].fourcc
== fb
->fmt
.pixelformat
)
1918 if (i
== NUM_FORMATS
) {
1919 dprintk(1, KERN_ERR
"%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
1920 ZR_DEVNAME(zr
), fb
->fmt
.pixelformat
,
1921 (char *)&printformat
);
1925 res
= setup_fbuffer(fh
, fb
->base
, &zoran_formats
[i
], fb
->fmt
.width
,
1926 fb
->fmt
.height
, fb
->fmt
.bytesperline
);
1931 static int zoran_overlay(struct file
*file
, void *__fh
, unsigned int on
)
1933 struct zoran_fh
*fh
= __fh
;
1936 res
= setup_overlay(fh
, on
);
1941 static int zoran_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
);
1943 static int zoran_reqbufs(struct file
*file
, void *__fh
, struct v4l2_requestbuffers
*req
)
1945 struct zoran_fh
*fh
= __fh
;
1946 struct zoran
*zr
= fh
->zr
;
1949 if (req
->memory
!= V4L2_MEMORY_MMAP
) {
1952 "%s: only MEMORY_MMAP capture is supported, not %d\n",
1953 ZR_DEVNAME(zr
), req
->memory
);
1957 if (req
->count
== 0)
1958 return zoran_streamoff(file
, fh
, req
->type
);
1960 if (fh
->buffers
.allocated
) {
1963 "%s: VIDIOC_REQBUFS - buffers already allocated\n",
1969 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
&&
1970 req
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1971 /* control user input */
1974 if (req
->count
> v4l_nbufs
)
1975 req
->count
= v4l_nbufs
;
1977 /* The next mmap will map the V4L buffers */
1979 fh
->buffers
.num_buffers
= req
->count
;
1981 if (v4l_fbuffer_alloc(fh
)) {
1985 } else if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
||
1986 fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
) {
1987 /* we need to calculate size ourselves now */
1990 if (req
->count
> jpg_nbufs
)
1991 req
->count
= jpg_nbufs
;
1993 /* The next mmap will map the MJPEG buffers */
1994 map_mode_jpg(fh
, req
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
);
1995 fh
->buffers
.num_buffers
= req
->count
;
1996 fh
->buffers
.buffer_size
= zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
1998 if (jpg_fbuffer_alloc(fh
)) {
2005 "%s: VIDIOC_REQBUFS - unknown type %d\n",
2006 ZR_DEVNAME(zr
), req
->type
);
2013 static int zoran_querybuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2015 struct zoran_fh
*fh
= __fh
;
2018 res
= zoran_v4l2_buffer_status(fh
, buf
, buf
->index
);
2023 static int zoran_qbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2025 struct zoran_fh
*fh
= __fh
;
2026 struct zoran
*zr
= fh
->zr
;
2027 int res
= 0, codec_mode
, buf_type
;
2029 switch (fh
->map_mode
) {
2030 case ZORAN_MAP_MODE_RAW
:
2031 if (buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2033 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2034 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2039 res
= zoran_v4l_queue_frame(fh
, buf
->index
);
2042 if (!zr
->v4l_memgrab_active
&& fh
->buffers
.active
== ZORAN_LOCKED
)
2043 zr36057_set_memgrab(zr
, 1);
2046 case ZORAN_MAP_MODE_JPG_REC
:
2047 case ZORAN_MAP_MODE_JPG_PLAY
:
2048 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
) {
2049 buf_type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2050 codec_mode
= BUZ_MODE_MOTION_DECOMPRESS
;
2052 buf_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2053 codec_mode
= BUZ_MODE_MOTION_COMPRESS
;
2056 if (buf
->type
!= buf_type
) {
2058 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2059 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2064 res
= zoran_jpg_queue_frame(fh
, buf
->index
, codec_mode
);
2067 if (zr
->codec_mode
== BUZ_MODE_IDLE
&&
2068 fh
->buffers
.active
== ZORAN_LOCKED
)
2069 zr36057_enable_jpg(zr
, codec_mode
);
2075 "%s: VIDIOC_QBUF - unsupported type %d\n",
2076 ZR_DEVNAME(zr
), buf
->type
);
2083 static int zoran_dqbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
2085 struct zoran_fh
*fh
= __fh
;
2086 struct zoran
*zr
= fh
->zr
;
2087 int res
= 0, buf_type
, num
= -1; /* compiler borks here (?) */
2089 switch (fh
->map_mode
) {
2090 case ZORAN_MAP_MODE_RAW
:
2091 if (buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
2093 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2094 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2099 num
= zr
->v4l_pend
[zr
->v4l_sync_tail
& V4L_MASK_FRAME
];
2100 if (file
->f_flags
& O_NONBLOCK
&&
2101 zr
->v4l_buffers
.buffer
[num
].state
!= BUZ_STATE_DONE
) {
2105 res
= v4l_sync(fh
, num
);
2108 zr
->v4l_sync_tail
++;
2109 res
= zoran_v4l2_buffer_status(fh
, buf
, num
);
2112 case ZORAN_MAP_MODE_JPG_REC
:
2113 case ZORAN_MAP_MODE_JPG_PLAY
:
2115 struct zoran_sync bs
;
2117 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_PLAY
)
2118 buf_type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2120 buf_type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2122 if (buf
->type
!= buf_type
) {
2124 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2125 ZR_DEVNAME(zr
), buf
->type
, fh
->map_mode
);
2130 num
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
2132 if (file
->f_flags
& O_NONBLOCK
&&
2133 zr
->jpg_buffers
.buffer
[num
].state
!= BUZ_STATE_DONE
) {
2137 bs
.frame
= 0; /* suppress compiler warning */
2138 res
= jpg_sync(fh
, &bs
);
2141 res
= zoran_v4l2_buffer_status(fh
, buf
, bs
.frame
);
2147 "%s: VIDIOC_DQBUF - unsupported type %d\n",
2148 ZR_DEVNAME(zr
), buf
->type
);
2155 static int zoran_streamon(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
2157 struct zoran_fh
*fh
= __fh
;
2158 struct zoran
*zr
= fh
->zr
;
2161 switch (fh
->map_mode
) {
2162 case ZORAN_MAP_MODE_RAW
: /* raw capture */
2163 if (zr
->v4l_buffers
.active
!= ZORAN_ACTIVE
||
2164 fh
->buffers
.active
!= ZORAN_ACTIVE
) {
2169 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_LOCKED
;
2170 zr
->v4l_settings
= fh
->v4l_settings
;
2172 zr
->v4l_sync_tail
= zr
->v4l_pend_tail
;
2173 if (!zr
->v4l_memgrab_active
&&
2174 zr
->v4l_pend_head
!= zr
->v4l_pend_tail
) {
2175 zr36057_set_memgrab(zr
, 1);
2179 case ZORAN_MAP_MODE_JPG_REC
:
2180 case ZORAN_MAP_MODE_JPG_PLAY
:
2181 /* what is the codec mode right now? */
2182 if (zr
->jpg_buffers
.active
!= ZORAN_ACTIVE
||
2183 fh
->buffers
.active
!= ZORAN_ACTIVE
) {
2188 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_LOCKED
;
2190 if (zr
->jpg_que_head
!= zr
->jpg_que_tail
) {
2191 /* Start the jpeg codec when the first frame is queued */
2199 "%s: VIDIOC_STREAMON - invalid map mode %d\n",
2200 ZR_DEVNAME(zr
), fh
->map_mode
);
2207 static int zoran_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
2209 struct zoran_fh
*fh
= __fh
;
2210 struct zoran
*zr
= fh
->zr
;
2212 unsigned long flags
;
2214 switch (fh
->map_mode
) {
2215 case ZORAN_MAP_MODE_RAW
: /* raw capture */
2216 if (fh
->buffers
.active
== ZORAN_FREE
&&
2217 zr
->v4l_buffers
.active
!= ZORAN_FREE
) {
2218 res
= -EPERM
; /* stay off other's settings! */
2221 if (zr
->v4l_buffers
.active
== ZORAN_FREE
)
2224 spin_lock_irqsave(&zr
->spinlock
, flags
);
2225 /* unload capture */
2226 if (zr
->v4l_memgrab_active
) {
2228 zr36057_set_memgrab(zr
, 0);
2231 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++)
2232 zr
->v4l_buffers
.buffer
[i
].state
= BUZ_STATE_USER
;
2233 fh
->buffers
= zr
->v4l_buffers
;
2235 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2237 zr
->v4l_grab_seq
= 0;
2238 zr
->v4l_pend_head
= zr
->v4l_pend_tail
= 0;
2239 zr
->v4l_sync_tail
= 0;
2241 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2245 case ZORAN_MAP_MODE_JPG_REC
:
2246 case ZORAN_MAP_MODE_JPG_PLAY
:
2247 if (fh
->buffers
.active
== ZORAN_FREE
&&
2248 zr
->jpg_buffers
.active
!= ZORAN_FREE
) {
2249 res
= -EPERM
; /* stay off other's settings! */
2252 if (zr
->jpg_buffers
.active
== ZORAN_FREE
)
2255 res
= jpg_qbuf(fh
, -1,
2256 (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
) ?
2257 BUZ_MODE_MOTION_COMPRESS
:
2258 BUZ_MODE_MOTION_DECOMPRESS
);
2264 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
2265 ZR_DEVNAME(zr
), fh
->map_mode
);
2271 static int zoran_g_std(struct file
*file
, void *__fh
, v4l2_std_id
*std
)
2273 struct zoran_fh
*fh
= __fh
;
2274 struct zoran
*zr
= fh
->zr
;
2280 static int zoran_s_std(struct file
*file
, void *__fh
, v4l2_std_id std
)
2282 struct zoran_fh
*fh
= __fh
;
2283 struct zoran
*zr
= fh
->zr
;
2286 res
= zoran_set_norm(zr
, std
);
2290 res
= wait_grab_pending(zr
);
2294 static int zoran_enum_input(struct file
*file
, void *__fh
,
2295 struct v4l2_input
*inp
)
2297 struct zoran_fh
*fh
= __fh
;
2298 struct zoran
*zr
= fh
->zr
;
2300 if (inp
->index
>= zr
->card
.inputs
)
2303 strncpy(inp
->name
, zr
->card
.input
[inp
->index
].name
,
2304 sizeof(inp
->name
) - 1);
2305 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
2306 inp
->std
= V4L2_STD_ALL
;
2308 /* Get status of video decoder */
2309 decoder_call(zr
, video
, g_input_status
, &inp
->status
);
2313 static int zoran_g_input(struct file
*file
, void *__fh
, unsigned int *input
)
2315 struct zoran_fh
*fh
= __fh
;
2316 struct zoran
*zr
= fh
->zr
;
2323 static int zoran_s_input(struct file
*file
, void *__fh
, unsigned int input
)
2325 struct zoran_fh
*fh
= __fh
;
2326 struct zoran
*zr
= fh
->zr
;
2329 res
= zoran_set_input(zr
, input
);
2333 /* Make sure the changes come into effect */
2334 res
= wait_grab_pending(zr
);
2338 static int zoran_enum_output(struct file
*file
, void *__fh
,
2339 struct v4l2_output
*outp
)
2341 if (outp
->index
!= 0)
2345 outp
->type
= V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY
;
2346 strncpy(outp
->name
, "Autodetect", sizeof(outp
->name
)-1);
2351 static int zoran_g_output(struct file
*file
, void *__fh
, unsigned int *output
)
2358 static int zoran_s_output(struct file
*file
, void *__fh
, unsigned int output
)
2366 /* cropping (sub-frame capture) */
2367 static int zoran_g_selection(struct file
*file
, void *__fh
, struct v4l2_selection
*sel
)
2369 struct zoran_fh
*fh
= __fh
;
2370 struct zoran
*zr
= fh
->zr
;
2372 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2373 sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2376 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
2378 "%s: VIDIOC_G_SELECTION - subcapture only supported for compressed capture\n",
2383 switch (sel
->target
) {
2384 case V4L2_SEL_TGT_CROP
:
2385 sel
->r
.top
= fh
->jpg_settings
.img_y
;
2386 sel
->r
.left
= fh
->jpg_settings
.img_x
;
2387 sel
->r
.width
= fh
->jpg_settings
.img_width
;
2388 sel
->r
.height
= fh
->jpg_settings
.img_height
;
2390 case V4L2_SEL_TGT_CROP_DEFAULT
:
2391 sel
->r
.top
= sel
->r
.left
= 0;
2392 sel
->r
.width
= BUZ_MIN_WIDTH
;
2393 sel
->r
.height
= BUZ_MIN_HEIGHT
;
2395 case V4L2_SEL_TGT_CROP_BOUNDS
:
2396 sel
->r
.top
= sel
->r
.left
= 0;
2397 sel
->r
.width
= BUZ_MAX_WIDTH
;
2398 sel
->r
.height
= BUZ_MAX_HEIGHT
;
2406 static int zoran_s_selection(struct file
*file
, void *__fh
, struct v4l2_selection
*sel
)
2408 struct zoran_fh
*fh
= __fh
;
2409 struct zoran
*zr
= fh
->zr
;
2410 struct zoran_jpg_settings settings
;
2413 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
2414 sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2417 if (sel
->target
!= V4L2_SEL_TGT_CROP
)
2420 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
2422 "%s: VIDIOC_S_SELECTION - subcapture only supported for compressed capture\n",
2427 settings
= fh
->jpg_settings
;
2429 if (fh
->buffers
.allocated
) {
2431 "%s: VIDIOC_S_SELECTION - cannot change settings while active\n",
2436 /* move into a form that we understand */
2437 settings
.img_x
= sel
->r
.left
;
2438 settings
.img_y
= sel
->r
.top
;
2439 settings
.img_width
= sel
->r
.width
;
2440 settings
.img_height
= sel
->r
.height
;
2442 /* check validity */
2443 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
2448 fh
->jpg_settings
= settings
;
2452 static int zoran_g_jpegcomp(struct file
*file
, void *__fh
,
2453 struct v4l2_jpegcompression
*params
)
2455 struct zoran_fh
*fh
= __fh
;
2456 memset(params
, 0, sizeof(*params
));
2458 params
->quality
= fh
->jpg_settings
.jpg_comp
.quality
;
2459 params
->APPn
= fh
->jpg_settings
.jpg_comp
.APPn
;
2460 memcpy(params
->APP_data
,
2461 fh
->jpg_settings
.jpg_comp
.APP_data
,
2462 fh
->jpg_settings
.jpg_comp
.APP_len
);
2463 params
->APP_len
= fh
->jpg_settings
.jpg_comp
.APP_len
;
2464 memcpy(params
->COM_data
,
2465 fh
->jpg_settings
.jpg_comp
.COM_data
,
2466 fh
->jpg_settings
.jpg_comp
.COM_len
);
2467 params
->COM_len
= fh
->jpg_settings
.jpg_comp
.COM_len
;
2468 params
->jpeg_markers
=
2469 fh
->jpg_settings
.jpg_comp
.jpeg_markers
;
2474 static int zoran_s_jpegcomp(struct file
*file
, void *__fh
,
2475 const struct v4l2_jpegcompression
*params
)
2477 struct zoran_fh
*fh
= __fh
;
2478 struct zoran
*zr
= fh
->zr
;
2480 struct zoran_jpg_settings settings
;
2482 settings
= fh
->jpg_settings
;
2484 settings
.jpg_comp
= *params
;
2486 if (fh
->buffers
.active
!= ZORAN_FREE
) {
2487 dprintk(1, KERN_WARNING
2488 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
2494 res
= zoran_check_jpg_settings(zr
, &settings
, 0);
2497 if (!fh
->buffers
.allocated
)
2498 fh
->buffers
.buffer_size
=
2499 zoran_v4l2_calc_bufsize(&fh
->jpg_settings
);
2500 fh
->jpg_settings
.jpg_comp
= settings
.jpg_comp
;
2505 zoran_poll (struct file
*file
,
2508 struct zoran_fh
*fh
= file
->private_data
;
2509 struct zoran
*zr
= fh
->zr
;
2510 int res
= v4l2_ctrl_poll(file
, wait
);
2512 unsigned long flags
;
2514 /* we should check whether buffers are ready to be synced on
2515 * (w/o waits - O_NONBLOCK) here
2516 * if ready for read (sync), return POLLIN|POLLRDNORM,
2517 * if ready for write (sync), return POLLOUT|POLLWRNORM,
2518 * if error, return POLLERR,
2519 * if no buffers queued or so, return POLLNVAL
2522 switch (fh
->map_mode
) {
2523 case ZORAN_MAP_MODE_RAW
:
2524 poll_wait(file
, &zr
->v4l_capq
, wait
);
2525 frame
= zr
->v4l_pend
[zr
->v4l_sync_tail
& V4L_MASK_FRAME
];
2527 spin_lock_irqsave(&zr
->spinlock
, flags
);
2530 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
2531 ZR_DEVNAME(zr
), __func__
,
2532 "FAL"[fh
->buffers
.active
], zr
->v4l_sync_tail
,
2533 "UPMD"[zr
->v4l_buffers
.buffer
[frame
].state
],
2534 zr
->v4l_pend_tail
, zr
->v4l_pend_head
);
2535 /* Process is the one capturing? */
2536 if (fh
->buffers
.active
!= ZORAN_FREE
&&
2537 /* Buffer ready to DQBUF? */
2538 zr
->v4l_buffers
.buffer
[frame
].state
== BUZ_STATE_DONE
)
2539 res
|= POLLIN
| POLLRDNORM
;
2540 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2544 case ZORAN_MAP_MODE_JPG_REC
:
2545 case ZORAN_MAP_MODE_JPG_PLAY
:
2546 poll_wait(file
, &zr
->jpg_capq
, wait
);
2547 frame
= zr
->jpg_pend
[zr
->jpg_que_tail
& BUZ_MASK_FRAME
];
2549 spin_lock_irqsave(&zr
->spinlock
, flags
);
2552 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
2553 ZR_DEVNAME(zr
), __func__
,
2554 "FAL"[fh
->buffers
.active
], zr
->jpg_que_tail
,
2555 "UPMD"[zr
->jpg_buffers
.buffer
[frame
].state
],
2556 zr
->jpg_que_head
, zr
->jpg_dma_tail
, zr
->jpg_dma_head
);
2557 if (fh
->buffers
.active
!= ZORAN_FREE
&&
2558 zr
->jpg_buffers
.buffer
[frame
].state
== BUZ_STATE_DONE
) {
2559 if (fh
->map_mode
== ZORAN_MAP_MODE_JPG_REC
)
2560 res
|= POLLIN
| POLLRDNORM
;
2562 res
|= POLLOUT
| POLLWRNORM
;
2564 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2571 "%s: %s - internal error, unknown map_mode=%d\n",
2572 ZR_DEVNAME(zr
), __func__
, fh
->map_mode
);
2581 * This maps the buffers to user space.
2583 * Depending on the state of fh->map_mode
2584 * the V4L or the MJPEG buffers are mapped
2585 * per buffer or all together
2587 * Note that we need to connect to some
2588 * unmap signal event to unmap the de-allocate
2589 * the buffer accordingly (zoran_vm_close())
2593 zoran_vm_open (struct vm_area_struct
*vma
)
2595 struct zoran_mapping
*map
= vma
->vm_private_data
;
2596 atomic_inc(&map
->count
);
2600 zoran_vm_close (struct vm_area_struct
*vma
)
2602 struct zoran_mapping
*map
= vma
->vm_private_data
;
2603 struct zoran_fh
*fh
= map
->fh
;
2604 struct zoran
*zr
= fh
->zr
;
2607 dprintk(3, KERN_INFO
"%s: %s - munmap(%s)\n", ZR_DEVNAME(zr
),
2608 __func__
, mode_name(fh
->map_mode
));
2610 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
2611 if (fh
->buffers
.buffer
[i
].map
== map
)
2612 fh
->buffers
.buffer
[i
].map
= NULL
;
2616 /* Any buffers still mapped? */
2617 for (i
= 0; i
< fh
->buffers
.num_buffers
; i
++) {
2618 if (fh
->buffers
.buffer
[i
].map
) {
2623 dprintk(3, KERN_INFO
"%s: %s - free %s buffers\n", ZR_DEVNAME(zr
),
2624 __func__
, mode_name(fh
->map_mode
));
2626 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
2627 if (fh
->buffers
.active
!= ZORAN_FREE
) {
2628 unsigned long flags
;
2630 spin_lock_irqsave(&zr
->spinlock
, flags
);
2631 zr36057_set_memgrab(zr
, 0);
2632 zr
->v4l_buffers
.allocated
= 0;
2633 zr
->v4l_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2634 spin_unlock_irqrestore(&zr
->spinlock
, flags
);
2636 v4l_fbuffer_free(fh
);
2638 if (fh
->buffers
.active
!= ZORAN_FREE
) {
2639 jpg_qbuf(fh
, -1, zr
->codec_mode
);
2640 zr
->jpg_buffers
.allocated
= 0;
2641 zr
->jpg_buffers
.active
= fh
->buffers
.active
= ZORAN_FREE
;
2643 jpg_fbuffer_free(fh
);
2647 static const struct vm_operations_struct zoran_vm_ops
= {
2648 .open
= zoran_vm_open
,
2649 .close
= zoran_vm_close
,
2653 zoran_mmap (struct file
*file
,
2654 struct vm_area_struct
*vma
)
2656 struct zoran_fh
*fh
= file
->private_data
;
2657 struct zoran
*zr
= fh
->zr
;
2658 unsigned long size
= (vma
->vm_end
- vma
->vm_start
);
2659 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
2661 unsigned long page
, start
= vma
->vm_start
, todo
, pos
, fraglen
;
2663 struct zoran_mapping
*map
;
2667 KERN_INFO
"%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
2668 ZR_DEVNAME(zr
), __func__
,
2669 mode_name(fh
->map_mode
), vma
->vm_start
, vma
->vm_end
, size
);
2671 if (!(vma
->vm_flags
& VM_SHARED
) || !(vma
->vm_flags
& VM_READ
) ||
2672 !(vma
->vm_flags
& VM_WRITE
)) {
2675 "%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n",
2676 ZR_DEVNAME(zr
), __func__
);
2680 if (!fh
->buffers
.allocated
) {
2683 "%s: %s(%s) - buffers not yet allocated\n",
2684 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
));
2689 first
= offset
/ fh
->buffers
.buffer_size
;
2690 last
= first
- 1 + size
/ fh
->buffers
.buffer_size
;
2691 if (offset
% fh
->buffers
.buffer_size
!= 0 ||
2692 size
% fh
->buffers
.buffer_size
!= 0 || first
< 0 ||
2693 last
< 0 || first
>= fh
->buffers
.num_buffers
||
2694 last
>= fh
->buffers
.buffer_size
) {
2697 "%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
2698 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
), offset
, size
,
2699 fh
->buffers
.buffer_size
,
2700 fh
->buffers
.num_buffers
);
2705 /* Check if any buffers are already mapped */
2706 for (i
= first
; i
<= last
; i
++) {
2707 if (fh
->buffers
.buffer
[i
].map
) {
2710 "%s: %s(%s) - buffer %d already mapped\n",
2711 ZR_DEVNAME(zr
), __func__
, mode_name(fh
->map_mode
), i
);
2717 /* map these buffers */
2718 map
= kmalloc(sizeof(struct zoran_mapping
), GFP_KERNEL
);
2724 atomic_set(&map
->count
, 1);
2726 vma
->vm_ops
= &zoran_vm_ops
;
2727 vma
->vm_flags
|= VM_DONTEXPAND
;
2728 vma
->vm_private_data
= map
;
2730 if (fh
->map_mode
== ZORAN_MAP_MODE_RAW
) {
2731 for (i
= first
; i
<= last
; i
++) {
2733 if (todo
> fh
->buffers
.buffer_size
)
2734 todo
= fh
->buffers
.buffer_size
;
2735 page
= fh
->buffers
.buffer
[i
].v4l
.fbuffer_phys
;
2736 if (remap_pfn_range(vma
, start
, page
>> PAGE_SHIFT
,
2737 todo
, PAGE_SHARED
)) {
2740 "%s: %s(V4L) - remap_pfn_range failed\n",
2741 ZR_DEVNAME(zr
), __func__
);
2747 fh
->buffers
.buffer
[i
].map
= map
;
2752 for (i
= first
; i
<= last
; i
++) {
2754 j
< fh
->buffers
.buffer_size
/ PAGE_SIZE
;
2757 (le32_to_cpu(fh
->buffers
.buffer
[i
].jpg
.
2758 frag_tab
[2 * j
+ 1]) & ~1) << 1;
2763 le32_to_cpu(fh
->buffers
.
2764 buffer
[i
].jpg
.frag_tab
[2 * j
]);
2765 /* should just be pos on i386 */
2766 page
= virt_to_phys(bus_to_virt(pos
))
2768 if (remap_pfn_range(vma
, start
, page
,
2769 todo
, PAGE_SHARED
)) {
2772 "%s: %s(V4L) - remap_pfn_range failed\n",
2773 ZR_DEVNAME(zr
), __func__
);
2781 if (le32_to_cpu(fh
->buffers
.buffer
[i
].jpg
.
2782 frag_tab
[2 * j
+ 1]) & 1)
2783 break; /* was last fragment */
2785 fh
->buffers
.buffer
[i
].map
= map
;
2794 static const struct v4l2_ioctl_ops zoran_ioctl_ops
= {
2795 .vidioc_querycap
= zoran_querycap
,
2796 .vidioc_s_selection
= zoran_s_selection
,
2797 .vidioc_g_selection
= zoran_g_selection
,
2798 .vidioc_enum_input
= zoran_enum_input
,
2799 .vidioc_g_input
= zoran_g_input
,
2800 .vidioc_s_input
= zoran_s_input
,
2801 .vidioc_enum_output
= zoran_enum_output
,
2802 .vidioc_g_output
= zoran_g_output
,
2803 .vidioc_s_output
= zoran_s_output
,
2804 .vidioc_g_fbuf
= zoran_g_fbuf
,
2805 .vidioc_s_fbuf
= zoran_s_fbuf
,
2806 .vidioc_g_std
= zoran_g_std
,
2807 .vidioc_s_std
= zoran_s_std
,
2808 .vidioc_g_jpegcomp
= zoran_g_jpegcomp
,
2809 .vidioc_s_jpegcomp
= zoran_s_jpegcomp
,
2810 .vidioc_overlay
= zoran_overlay
,
2811 .vidioc_reqbufs
= zoran_reqbufs
,
2812 .vidioc_querybuf
= zoran_querybuf
,
2813 .vidioc_qbuf
= zoran_qbuf
,
2814 .vidioc_dqbuf
= zoran_dqbuf
,
2815 .vidioc_streamon
= zoran_streamon
,
2816 .vidioc_streamoff
= zoran_streamoff
,
2817 .vidioc_enum_fmt_vid_cap
= zoran_enum_fmt_vid_cap
,
2818 .vidioc_enum_fmt_vid_out
= zoran_enum_fmt_vid_out
,
2819 .vidioc_enum_fmt_vid_overlay
= zoran_enum_fmt_vid_overlay
,
2820 .vidioc_g_fmt_vid_cap
= zoran_g_fmt_vid_cap
,
2821 .vidioc_g_fmt_vid_out
= zoran_g_fmt_vid_out
,
2822 .vidioc_g_fmt_vid_overlay
= zoran_g_fmt_vid_overlay
,
2823 .vidioc_s_fmt_vid_cap
= zoran_s_fmt_vid_cap
,
2824 .vidioc_s_fmt_vid_out
= zoran_s_fmt_vid_out
,
2825 .vidioc_s_fmt_vid_overlay
= zoran_s_fmt_vid_overlay
,
2826 .vidioc_try_fmt_vid_cap
= zoran_try_fmt_vid_cap
,
2827 .vidioc_try_fmt_vid_out
= zoran_try_fmt_vid_out
,
2828 .vidioc_try_fmt_vid_overlay
= zoran_try_fmt_vid_overlay
,
2829 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
2830 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
2833 static const struct v4l2_file_operations zoran_fops
= {
2834 .owner
= THIS_MODULE
,
2836 .release
= zoran_close
,
2837 .unlocked_ioctl
= video_ioctl2
,
2842 const struct video_device zoran_template
= {
2844 .fops
= &zoran_fops
,
2845 .ioctl_ops
= &zoran_ioctl_ops
,
2846 .release
= &zoran_vdev_release
,
2847 .tvnorms
= V4L2_STD_NTSC
| V4L2_STD_PAL
| V4L2_STD_SECAM
,