1/*
2 * Zoran zr36057/zr36067 PCI controller driver, for the
3 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
4 * Media Labs LML33/LML33R10.
5 *
6 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
7 *
8 * Changes for BUZ by Wolfgang Scherr <scherr@net4you.net>
9 *
10 * Changes for DC10/DC30 by Laurent Pinchart <laurent.pinchart@skynet.be>
11 *
12 * Changes for LML33R10 by Maxim Yevtyushkin <max@linuxmedialabs.com>
13 *
14 * Changes for videodev2/v4l2 by Ronald Bultje <rbultje@ronald.bitfreak.net>
15 *
16 * Based on
17 *
18 * Miro DC10 driver
19 * Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net>
20 *
21 * Iomega Buz driver version 1.0
22 * Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de>
23 *
24 * buz.0.0.3
25 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
26 *
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)
30 *
31 *
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.
36 *
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.
41 *
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.
45 */
46
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>
54
55#include <linux/interrupt.h>
56#include <linux/i2c.h>
57#include <linux/i2c-algo-bit.h>
58
59#include <linux/spinlock.h>
60
61#include <linux/videodev2.h>
62#include <media/v4l2-common.h>
63#include <media/v4l2-ioctl.h>
64#include "videocodec.h"
65
66#include <asm/byteorder.h>
67#include <asm/io.h>
68#include <asm/uaccess.h>
69#include <linux/proc_fs.h>
70
71#include <linux/mutex.h>
72#include "zoran.h"
73#include "zoran_device.h"
74#include "zoran_card.h"
75
76
77const struct zoran_format zoran_formats[] = {
78	{
79		.name = "15-bit RGB LE",
80		.fourcc = V4L2_PIX_FMT_RGB555,
81		.colorspace = V4L2_COLORSPACE_SRGB,
82		.depth = 15,
83		.flags = ZORAN_FORMAT_CAPTURE |
84			 ZORAN_FORMAT_OVERLAY,
85		.vfespfr = ZR36057_VFESPFR_RGB555|ZR36057_VFESPFR_ErrDif|
86			   ZR36057_VFESPFR_LittleEndian,
87	}, {
88		.name = "15-bit RGB BE",
89		.fourcc = V4L2_PIX_FMT_RGB555X,
90		.colorspace = V4L2_COLORSPACE_SRGB,
91		.depth = 15,
92		.flags = ZORAN_FORMAT_CAPTURE |
93			 ZORAN_FORMAT_OVERLAY,
94		.vfespfr = ZR36057_VFESPFR_RGB555|ZR36057_VFESPFR_ErrDif,
95	}, {
96		.name = "16-bit RGB LE",
97		.fourcc = V4L2_PIX_FMT_RGB565,
98		.colorspace = V4L2_COLORSPACE_SRGB,
99		.depth = 16,
100		.flags = ZORAN_FORMAT_CAPTURE |
101			 ZORAN_FORMAT_OVERLAY,
102		.vfespfr = ZR36057_VFESPFR_RGB565|ZR36057_VFESPFR_ErrDif|
103			   ZR36057_VFESPFR_LittleEndian,
104	}, {
105		.name = "16-bit RGB BE",
106		.fourcc = V4L2_PIX_FMT_RGB565X,
107		.colorspace = V4L2_COLORSPACE_SRGB,
108		.depth = 16,
109		.flags = ZORAN_FORMAT_CAPTURE |
110			 ZORAN_FORMAT_OVERLAY,
111		.vfespfr = ZR36057_VFESPFR_RGB565|ZR36057_VFESPFR_ErrDif,
112	}, {
113		.name = "24-bit RGB",
114		.fourcc = V4L2_PIX_FMT_BGR24,
115		.colorspace = V4L2_COLORSPACE_SRGB,
116		.depth = 24,
117		.flags = ZORAN_FORMAT_CAPTURE |
118			 ZORAN_FORMAT_OVERLAY,
119		.vfespfr = ZR36057_VFESPFR_RGB888|ZR36057_VFESPFR_Pack24,
120	}, {
121		.name = "32-bit RGB LE",
122		.fourcc = V4L2_PIX_FMT_BGR32,
123		.colorspace = V4L2_COLORSPACE_SRGB,
124		.depth = 32,
125		.flags = ZORAN_FORMAT_CAPTURE |
126			 ZORAN_FORMAT_OVERLAY,
127		.vfespfr = ZR36057_VFESPFR_RGB888|ZR36057_VFESPFR_LittleEndian,
128	}, {
129		.name = "32-bit RGB BE",
130		.fourcc = V4L2_PIX_FMT_RGB32,
131		.colorspace = V4L2_COLORSPACE_SRGB,
132		.depth = 32,
133		.flags = ZORAN_FORMAT_CAPTURE |
134			 ZORAN_FORMAT_OVERLAY,
135		.vfespfr = ZR36057_VFESPFR_RGB888,
136	}, {
137		.name = "4:2:2, packed, YUYV",
138		.fourcc = V4L2_PIX_FMT_YUYV,
139		.colorspace = V4L2_COLORSPACE_SMPTE170M,
140		.depth = 16,
141		.flags = ZORAN_FORMAT_CAPTURE |
142			 ZORAN_FORMAT_OVERLAY,
143		.vfespfr = ZR36057_VFESPFR_YUV422,
144	}, {
145		.name = "4:2:2, packed, UYVY",
146		.fourcc = V4L2_PIX_FMT_UYVY,
147		.colorspace = V4L2_COLORSPACE_SMPTE170M,
148		.depth = 16,
149		.flags = ZORAN_FORMAT_CAPTURE |
150			 ZORAN_FORMAT_OVERLAY,
151		.vfespfr = ZR36057_VFESPFR_YUV422|ZR36057_VFESPFR_LittleEndian,
152	}, {
153		.name = "Hardware-encoded Motion-JPEG",
154		.fourcc = V4L2_PIX_FMT_MJPEG,
155		.colorspace = V4L2_COLORSPACE_SMPTE170M,
156		.depth = 0,
157		.flags = ZORAN_FORMAT_CAPTURE |
158			 ZORAN_FORMAT_PLAYBACK |
159			 ZORAN_FORMAT_COMPRESSED,
160	}
161};
162#define NUM_FORMATS ARRAY_SIZE(zoran_formats)
163
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 */
167static __u32
168zoran_v4l2_calc_bufsize (struct zoran_jpg_settings *settings)
169{
170	__u8 div = settings->VerDcm * settings->HorDcm * settings->TmpDcm;
171	__u32 num = (1024 * 512) / (div);
172	__u32 result = 2;
173
174	num--;
175	while (num) {
176		num >>= 1;
177		result <<= 1;
178	}
179
180	if (result > jpg_bufsize)
181		return jpg_bufsize;
182	if (result < 8192)
183		return 8192;
184	return result;
185}
186
187/* forward references */
188static void v4l_fbuffer_free(struct zoran_fh *fh);
189static void jpg_fbuffer_free(struct zoran_fh *fh);
190
191/* Set mapping mode */
192static void map_mode_raw(struct zoran_fh *fh)
193{
194	fh->map_mode = ZORAN_MAP_MODE_RAW;
195	fh->buffers.buffer_size = v4l_bufsize;
196	fh->buffers.num_buffers = v4l_nbufs;
197}
198static void map_mode_jpg(struct zoran_fh *fh, int play)
199{
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;
203}
204static inline const char *mode_name(enum zoran_map_mode mode)
205{
206	return mode == ZORAN_MAP_MODE_RAW ? "V4L" : "JPG";
207}
208
209/*
210 *   Allocate the V4L grab buffers
211 *
212 *   These have to be pysically contiguous.
213 */
214
215static int v4l_fbuffer_alloc(struct zoran_fh *fh)
216{
217	struct zoran *zr = fh->zr;
218	int i, off;
219	unsigned char *mem;
220
221	for (i = 0; i < fh->buffers.num_buffers; i++) {
222		if (fh->buffers.buffer[i].v4l.fbuffer)
223			dprintk(2,
224				KERN_WARNING
225				"%s: %s - buffer %d already allocated!?\n",
226				ZR_DEVNAME(zr), __func__, i);
227
228		//udelay(20);
229		mem = kmalloc(fh->buffers.buffer_size,
230			      GFP_KERNEL | __GFP_NOWARN);
231		if (!mem) {
232			dprintk(1,
233				KERN_ERR
234				"%s: %s - kmalloc for V4L buf %d failed\n",
235				ZR_DEVNAME(zr), __func__, i);
236			v4l_fbuffer_free(fh);
237			return -ENOBUFS;
238		}
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;
243		     off += PAGE_SIZE)
244			SetPageReserved(virt_to_page(mem + off));
245		dprintk(4,
246			KERN_INFO
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));
250	}
251
252	fh->buffers.allocated = 1;
253
254	return 0;
255}
256
257/* free the V4L grab buffers */
258static void v4l_fbuffer_free(struct zoran_fh *fh)
259{
260	struct zoran *zr = fh->zr;
261	int i, off;
262	unsigned char *mem;
263
264	dprintk(4, KERN_INFO "%s: %s\n", ZR_DEVNAME(zr), __func__);
265
266	for (i = 0; i < fh->buffers.num_buffers; i++) {
267		if (!fh->buffers.buffer[i].v4l.fbuffer)
268			continue;
269
270		mem = fh->buffers.buffer[i].v4l.fbuffer;
271		for (off = 0; off < fh->buffers.buffer_size;
272		     off += PAGE_SIZE)
273			ClearPageReserved(virt_to_page(mem + off));
274		kfree(fh->buffers.buffer[i].v4l.fbuffer);
275		fh->buffers.buffer[i].v4l.fbuffer = NULL;
276	}
277
278	fh->buffers.allocated = 0;
279}
280
281/*
282 *   Allocate the MJPEG grab buffers.
283 *
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)
288 *
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.
296 *
297 *   Ben Capper:
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.
307 */
308
309static int jpg_fbuffer_alloc(struct zoran_fh *fh)
310{
311	struct zoran *zr = fh->zr;
312	int i, j, off;
313	u8 *mem;
314
315	for (i = 0; i < fh->buffers.num_buffers; i++) {
316		if (fh->buffers.buffer[i].jpg.frag_tab)
317			dprintk(2,
318				KERN_WARNING
319				"%s: %s - buffer %d already allocated!?\n",
320				ZR_DEVNAME(zr), __func__, i);
321
322		/* Allocate fragment table for this buffer */
323
324		mem = (void *)get_zeroed_page(GFP_KERNEL);
325		if (!mem) {
326			dprintk(1,
327				KERN_ERR
328				"%s: %s - get_zeroed_page (frag_tab) failed for buffer %d\n",
329				ZR_DEVNAME(zr), __func__, i);
330			jpg_fbuffer_free(fh);
331			return -ENOBUFS;
332		}
333		fh->buffers.buffer[i].jpg.frag_tab = (__le32 *)mem;
334		fh->buffers.buffer[i].jpg.frag_tab_bus = virt_to_bus(mem);
335
336		if (fh->buffers.need_contiguous) {
337			mem = kmalloc(fh->buffers.buffer_size, GFP_KERNEL);
338			if (mem == NULL) {
339				dprintk(1,
340					KERN_ERR
341					"%s: %s - kmalloc failed for buffer %d\n",
342					ZR_DEVNAME(zr), __func__, i);
343				jpg_fbuffer_free(fh);
344				return -ENOBUFS;
345			}
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));
352		} else {
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);
356				if (mem == NULL) {
357					dprintk(1,
358						KERN_ERR
359						"%s: %s - get_zeroed_page failed for buffer %d\n",
360						ZR_DEVNAME(zr), __func__, i);
361					jpg_fbuffer_free(fh);
362					return -ENOBUFS;
363				}
364
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));
370			}
371
372			fh->buffers.buffer[i].jpg.frag_tab[2 * j - 1] |= cpu_to_le32(1);
373		}
374	}
375
376	dprintk(4,
377		KERN_DEBUG "%s: %s - %d KB allocated\n",
378		ZR_DEVNAME(zr), __func__,
379		(fh->buffers.num_buffers * fh->buffers.buffer_size) >> 10);
380
381	fh->buffers.allocated = 1;
382
383	return 0;
384}
385
386/* free the MJPEG grab buffers */
387static void jpg_fbuffer_free(struct zoran_fh *fh)
388{
389	struct zoran *zr = fh->zr;
390	int i, j, off;
391	unsigned char *mem;
392	__le32 frag_tab;
393	struct zoran_buffer *buffer;
394
395	dprintk(4, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
396
397	for (i = 0, buffer = &fh->buffers.buffer[0];
398	     i < fh->buffers.num_buffers; i++, buffer++) {
399		if (!buffer->jpg.frag_tab)
400			continue;
401
402		if (fh->buffers.need_contiguous) {
403			frag_tab = buffer->jpg.frag_tab[0];
404
405			if (frag_tab) {
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));
409				kfree(mem);
410				buffer->jpg.frag_tab[0] = 0;
411				buffer->jpg.frag_tab[1] = 0;
412			}
413		} else {
414			for (j = 0; j < fh->buffers.buffer_size / PAGE_SIZE; j++) {
415				frag_tab = buffer->jpg.frag_tab[2 * j];
416
417				if (!frag_tab)
418					break;
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;
423			}
424		}
425
426		free_page((unsigned long)buffer->jpg.frag_tab);
427		buffer->jpg.frag_tab = NULL;
428	}
429
430	fh->buffers.allocated = 0;
431}
432
433/*
434 *   V4L Buffer grabbing
435 */
436
437static int
438zoran_v4l_set_format (struct zoran_fh           *fh,
439		      int                        width,
440		      int                        height,
441		      const struct zoran_format *format)
442{
443	struct zoran *zr = fh->zr;
444	int bpp;
445
446	/* Check size and format of the grab wanted */
447
448	if (height < BUZ_MIN_HEIGHT || width < BUZ_MIN_WIDTH ||
449	    height > BUZ_MAX_HEIGHT || width > BUZ_MAX_WIDTH) {
450		dprintk(1,
451			KERN_ERR
452			"%s: %s - wrong frame size (%dx%d)\n",
453			ZR_DEVNAME(zr), __func__, width, height);
454		return -EINVAL;
455	}
456
457	bpp = (format->depth + 7) / 8;
458
459	/* Check against available buffer size */
460	if (height * width * bpp > fh->buffers.buffer_size) {
461		dprintk(1,
462			KERN_ERR
463			"%s: %s - video buffer size (%d kB) is too small\n",
464			ZR_DEVNAME(zr), __func__, fh->buffers.buffer_size >> 10);
465		return -EINVAL;
466	}
467
468	/* The video front end needs 4-byte alinged line sizes */
469
470	if ((bpp == 2 && (width & 1)) || (bpp == 3 && (width & 3))) {
471		dprintk(1,
472			KERN_ERR
473			"%s: %s - wrong frame alignment\n",
474			ZR_DEVNAME(zr), __func__);
475		return -EINVAL;
476	}
477
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;
482
483	return 0;
484}
485
486static int zoran_v4l_queue_frame(struct zoran_fh *fh, int num)
487{
488	struct zoran *zr = fh->zr;
489	unsigned long flags;
490	int res = 0;
491
492	if (!fh->buffers.allocated) {
493		dprintk(1,
494			KERN_ERR
495			"%s: %s - buffers not yet allocated\n",
496			ZR_DEVNAME(zr), __func__);
497		res = -ENOMEM;
498	}
499
500	/* No grabbing outside the buffer range! */
501	if (num >= fh->buffers.num_buffers || num < 0) {
502		dprintk(1,
503			KERN_ERR
504			"%s: %s - buffer %d is out of range\n",
505			ZR_DEVNAME(zr), __func__, num);
506		res = -EINVAL;
507	}
508
509	spin_lock_irqsave(&zr->spinlock, flags);
510
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;
515		} else {
516			dprintk(1,
517				KERN_ERR
518				"%s: %s - another session is already capturing\n",
519				ZR_DEVNAME(zr), __func__);
520			res = -EBUSY;
521		}
522	}
523
524	/* make sure a grab isn't going on currently with this buffer */
525	if (!res) {
526		switch (zr->v4l_buffers.buffer[num].state) {
527		default:
528		case BUZ_STATE_PEND:
529			if (zr->v4l_buffers.active == ZORAN_FREE) {
530				fh->buffers.active = ZORAN_FREE;
531				zr->v4l_buffers.allocated = 0;
532			}
533			res = -EBUSY;	/* what are you doing? */
534			break;
535		case BUZ_STATE_DONE:
536			dprintk(2,
537				KERN_WARNING
538				"%s: %s - queueing buffer %d in state DONE!?\n",
539				ZR_DEVNAME(zr), __func__, num);
540		case BUZ_STATE_USER:
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];
549			break;
550		}
551	}
552
553	spin_unlock_irqrestore(&zr->spinlock, flags);
554
555	if (!res && zr->v4l_buffers.active == ZORAN_FREE)
556		zr->v4l_buffers.active = fh->buffers.active;
557
558	return res;
559}
560
561/*
562 * Sync on a V4L buffer
563 */
564
565static int v4l_sync(struct zoran_fh *fh, int frame)
566{
567	struct zoran *zr = fh->zr;
568	unsigned long flags;
569
570	if (fh->buffers.active == ZORAN_FREE) {
571		dprintk(1,
572			KERN_ERR
573			"%s: %s - no grab active for this session\n",
574			ZR_DEVNAME(zr), __func__);
575		return -EINVAL;
576	}
577
578	/* check passed-in frame number */
579	if (frame >= fh->buffers.num_buffers || frame < 0) {
580		dprintk(1,
581			KERN_ERR "%s: %s - frame %d is invalid\n",
582			ZR_DEVNAME(zr), __func__, frame);
583		return -EINVAL;
584	}
585
586	/* Check if is buffer was queued at all */
587	if (zr->v4l_buffers.buffer[frame].state == BUZ_STATE_USER) {
588		dprintk(1,
589			KERN_ERR
590			"%s: %s - attempt to sync on a buffer which was not queued?\n",
591			ZR_DEVNAME(zr), __func__);
592		return -EPROTO;
593	}
594
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))
598		return -ETIME;
599	if (signal_pending(current))
600		return -ERESTARTSYS;
601
602	/* buffer should now be in BUZ_STATE_DONE */
603	if (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_DONE)
604		dprintk(2,
605			KERN_ERR "%s: %s - internal state error\n",
606			ZR_DEVNAME(zr), __func__);
607
608	zr->v4l_buffers.buffer[frame].state = BUZ_STATE_USER;
609	fh->buffers.buffer[frame] = zr->v4l_buffers.buffer[frame];
610
611	spin_lock_irqsave(&zr->spinlock, flags);
612
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;
619		}
620	}
621
622	spin_unlock_irqrestore(&zr->spinlock, flags);
623
624	return 0;
625}
626
627/*
628 *   Queue a MJPEG buffer for capture/playback
629 */
630
631static int zoran_jpg_queue_frame(struct zoran_fh *fh, int num,
632				 enum zoran_codec_mode mode)
633{
634	struct zoran *zr = fh->zr;
635	unsigned long flags;
636	int res = 0;
637
638	/* Check if buffers are allocated */
639	if (!fh->buffers.allocated) {
640		dprintk(1,
641			KERN_ERR
642			"%s: %s - buffers not yet allocated\n",
643			ZR_DEVNAME(zr), __func__);
644		return -ENOMEM;
645	}
646
647	/* No grabbing outside the buffer range! */
648	if (num >= fh->buffers.num_buffers || num < 0) {
649		dprintk(1,
650			KERN_ERR
651			"%s: %s - buffer %d out of range\n",
652			ZR_DEVNAME(zr), __func__, num);
653		return -EINVAL;
654	}
655
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 */
661		dprintk(1,
662			KERN_ERR
663			"%s: %s - codec in wrong mode\n",
664			ZR_DEVNAME(zr), __func__);
665		return -EINVAL;
666	}
667
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;
672		} else {
673			dprintk(1,
674				KERN_ERR
675				"%s: %s - another session is already capturing\n",
676				ZR_DEVNAME(zr), __func__);
677			res = -EBUSY;
678		}
679	}
680
681	if (!res && zr->codec_mode == BUZ_MODE_IDLE) {
682		/* Ok load up the jpeg codec */
683		zr36057_enable_jpg(zr, mode);
684	}
685
686	spin_lock_irqsave(&zr->spinlock, flags);
687
688	if (!res) {
689		switch (zr->jpg_buffers.buffer[num].state) {
690		case BUZ_STATE_DONE:
691			dprintk(2,
692				KERN_WARNING
693				"%s: %s - queing frame in BUZ_STATE_DONE state!?\n",
694				ZR_DEVNAME(zr), __func__);
695		case BUZ_STATE_USER:
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);
702			break;
703		default:
704		case BUZ_STATE_DMA:
705		case BUZ_STATE_PEND:
706			if (zr->jpg_buffers.active == ZORAN_FREE) {
707				fh->buffers.active = ZORAN_FREE;
708				zr->jpg_buffers.allocated = 0;
709			}
710			res = -EBUSY;	/* what are you doing? */
711			break;
712		}
713	}
714
715	spin_unlock_irqrestore(&zr->spinlock, flags);
716
717	if (!res && zr->jpg_buffers.active == ZORAN_FREE)
718		zr->jpg_buffers.active = fh->buffers.active;
719
720	return res;
721}
722
723static int jpg_qbuf(struct zoran_fh *fh, int frame, enum zoran_codec_mode mode)
724{
725	struct zoran *zr = fh->zr;
726	int res = 0;
727
728	/* Does the user want to stop streaming? */
729	if (frame < 0) {
730		if (zr->codec_mode == mode) {
731			if (fh->buffers.active == ZORAN_FREE) {
732				dprintk(1,
733					KERN_ERR
734					"%s: %s(-1) - session not active\n",
735					ZR_DEVNAME(zr), __func__);
736				return -EINVAL;
737			}
738			fh->buffers.active = zr->jpg_buffers.active = ZORAN_FREE;
739			zr->jpg_buffers.allocated = 0;
740			zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
741			return 0;
742		} else {
743			dprintk(1,
744				KERN_ERR
745				"%s: %s - stop streaming but not in streaming mode\n",
746				ZR_DEVNAME(zr), __func__);
747			return -EINVAL;
748		}
749	}
750
751	if ((res = zoran_jpg_queue_frame(fh, frame, mode)))
752		return res;
753
754	/* Start the jpeg codec when the first frame is queued  */
755	if (!res && zr->jpg_que_head == 1)
756		jpeg_start(zr);
757
758	return res;
759}
760
761/*
762 *   Sync on a MJPEG buffer
763 */
764
765static int jpg_sync(struct zoran_fh *fh, struct zoran_sync *bs)
766{
767	struct zoran *zr = fh->zr;
768	unsigned long flags;
769	int frame;
770
771	if (fh->buffers.active == ZORAN_FREE) {
772		dprintk(1,
773			KERN_ERR
774			"%s: %s - capture is not currently active\n",
775			ZR_DEVNAME(zr), __func__);
776		return -EINVAL;
777	}
778	if (zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS &&
779	    zr->codec_mode != BUZ_MODE_MOTION_COMPRESS) {
780		dprintk(1,
781			KERN_ERR
782			"%s: %s - codec not in streaming mode\n",
783			ZR_DEVNAME(zr), __func__);
784		return -EINVAL;
785	}
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),
789			10*HZ)) {
790		int isr;
791
792		btand(~ZR36057_JMC_Go_en, ZR36057_JMC);
793		udelay(1);
794		zr->codec->control(zr->codec, CODEC_G_STATUS,
795					   sizeof(isr), &isr);
796		dprintk(1,
797			KERN_ERR
798			"%s: %s - timeout: codec isr=0x%02x\n",
799			ZR_DEVNAME(zr), __func__, isr);
800
801		return -ETIME;
802
803	}
804	if (signal_pending(current))
805		return -ERESTARTSYS;
806
807	spin_lock_irqsave(&zr->spinlock, flags);
808
809	if (zr->jpg_dma_tail != zr->jpg_dma_head)
810		frame = zr->jpg_pend[zr->jpg_que_tail++ & BUZ_MASK_FRAME];
811	else
812		frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
813
814	/* buffer should now be in BUZ_STATE_DONE */
815	if (zr->jpg_buffers.buffer[frame].state != BUZ_STATE_DONE)
816		dprintk(2,
817			KERN_ERR "%s: %s - internal state error\n",
818			ZR_DEVNAME(zr), __func__);
819
820	*bs = zr->jpg_buffers.buffer[frame].bs;
821	bs->frame = frame;
822	zr->jpg_buffers.buffer[frame].state = BUZ_STATE_USER;
823	fh->buffers.buffer[frame] = zr->jpg_buffers.buffer[frame];
824
825	spin_unlock_irqrestore(&zr->spinlock, flags);
826
827	return 0;
828}
829
830static void zoran_open_init_session(struct zoran_fh *fh)
831{
832	int i;
833	struct zoran *zr = fh->zr;
834
835	/* Per default, map the V4L Buffers */
836	map_mode_raw(fh);
837
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;
843
844	/* v4l settings */
845	fh->v4l_settings = zr->v4l_settings;
846	/* jpg settings */
847	fh->jpg_settings = zr->jpg_settings;
848
849	/* buffers */
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;
854	}
855	fh->buffers.allocated = 0;
856	fh->buffers.active = ZORAN_FREE;
857}
858
859static void zoran_close_end_session(struct zoran_fh *fh)
860{
861	struct zoran *zr = fh->zr;
862
863	/* overlay */
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;
870	}
871
872	if (fh->map_mode == ZORAN_MAP_MODE_RAW) {
873		/* v4l capture */
874		if (fh->buffers.active != ZORAN_FREE) {
875			unsigned long flags;
876
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);
882		}
883
884		/* v4l buffers */
885		if (fh->buffers.allocated)
886			v4l_fbuffer_free(fh);
887	} else {
888		/* jpg capture */
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;
893		}
894
895		/* jpg buffers */
896		if (fh->buffers.allocated)
897			jpg_fbuffer_free(fh);
898	}
899}
900
901/*
902 *   Open a zoran card. Right now the flags stuff is just playing
903 */
904
905static int zoran_open(struct file *file)
906{
907	struct zoran *zr = video_drvdata(file);
908	struct zoran_fh *fh;
909	int res, first_open = 0;
910
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);
913
914	mutex_lock(&zr->other_lock);
915
916	if (zr->user >= 2048) {
917		dprintk(1, KERN_ERR "%s: too many users (%d) on device\n",
918			ZR_DEVNAME(zr), zr->user);
919		res = -EBUSY;
920		goto fail_unlock;
921	}
922
923	/* now, create the open()-specific file_ops struct */
924	fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL);
925	if (!fh) {
926		dprintk(1,
927			KERN_ERR
928			"%s: %s - allocation of zoran_fh failed\n",
929			ZR_DEVNAME(zr), __func__);
930		res = -ENOMEM;
931		goto fail_unlock;
932	}
933	/* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
934	 * on norm-change! */
935	fh->overlay_mask =
936	    kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL);
937	if (!fh->overlay_mask) {
938		dprintk(1,
939			KERN_ERR
940			"%s: %s - allocation of overlay_mask failed\n",
941			ZR_DEVNAME(zr), __func__);
942		res = -ENOMEM;
943		goto fail_fh;
944	}
945
946	if (zr->user++ == 0)
947		first_open = 1;
948
949	/*mutex_unlock(&zr->resource_lock);*/
950
951	/* default setup - TODO: look at flags */
952	if (first_open) {	/* First device open */
953		zr36057_restart(zr);
954		zoran_open_init_params(zr);
955		zoran_init_hardware(zr);
956
957		btor(ZR36057_ICR_IntPinEn, ZR36057_ICR);
958	}
959
960	/* set file_ops stuff */
961	file->private_data = fh;
962	fh->zr = zr;
963	zoran_open_init_session(fh);
964	mutex_unlock(&zr->other_lock);
965
966	return 0;
967
968fail_fh:
969	kfree(fh);
970fail_unlock:
971	mutex_unlock(&zr->other_lock);
972
973	dprintk(2, KERN_INFO "%s: open failed (%d), users(-)=%d\n",
974		ZR_DEVNAME(zr), res, zr->user);
975
976	return res;
977}
978
979static int
980zoran_close(struct file  *file)
981{
982	struct zoran_fh *fh = file->private_data;
983	struct zoran *zr = fh->zr;
984
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);
987
988	/* kernel locks (fs/device.c), so don't do that ourselves
989	 * (prevents deadlocks) */
990	mutex_lock(&zr->other_lock);
991
992	zoran_close_end_session(fh);
993
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;
1000
1001		/* disable interrupts */
1002		btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);
1003
1004		if (zr36067_debug > 1)
1005			print_interrupts(zr);
1006
1007		/* Overlay off */
1008		zr->v4l_overlay_active = 0;
1009		zr36057_overlay(zr, 0);
1010		zr->overlay_mask = NULL;
1011
1012		/* capture off */
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);
1018
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);
1022		}
1023	}
1024	mutex_unlock(&zr->other_lock);
1025
1026	file->private_data = NULL;
1027	kfree(fh->overlay_mask);
1028	kfree(fh);
1029
1030	dprintk(4, KERN_INFO "%s: %s done\n", ZR_DEVNAME(zr), __func__);
1031
1032	return 0;
1033}
1034
1035
1036static ssize_t
1037zoran_read (struct file *file,
1038	    char        __user *data,
1039	    size_t       count,
1040	    loff_t      *ppos)
1041{
1042	/* we simply don't support read() (yet)... */
1043
1044	return -EINVAL;
1045}
1046
1047static ssize_t
1048zoran_write (struct file *file,
1049	     const char  __user *data,
1050	     size_t       count,
1051	     loff_t      *ppos)
1052{
1053	/* ...and the same goes for write() */
1054
1055	return -EINVAL;
1056}
1057
1058static int setup_fbuffer(struct zoran_fh *fh,
1059	       void                      *base,
1060	       const struct zoran_format *fmt,
1061	       int                        width,
1062	       int                        height,
1063	       int                        bytesperline)
1064{
1065	struct zoran *zr = fh->zr;
1066
1067	/* (Ronald) v4l/v4l2 guidelines */
1068	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
1069		return -EPERM;
1070
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) */
1074
1075	if (pci_pci_problems & (PCIPCI_FAIL | PCIAGP_FAIL | PCIPCI_ALIMAGIK))
1076		return -ENXIO;
1077
1078	/* we need a bytesperline value, even if not given */
1079	if (!bytesperline)
1080		bytesperline = width * ((fmt->depth + 7) & ~7) / 8;
1081
1082#if 0
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 */
1090		dprintk(3,
1091			KERN_ERR
1092			"%s: %s - forced overlay turnoff because framebuffer changed\n",
1093			ZR_DEVNAME(zr), __func__);
1094		zr36057_overlay(zr, 0);
1095	}
1096#endif
1097
1098	if (!(fmt->flags & ZORAN_FORMAT_OVERLAY)) {
1099		dprintk(1,
1100			KERN_ERR
1101			"%s: %s - no valid overlay format given\n",
1102			ZR_DEVNAME(zr), __func__);
1103		return -EINVAL;
1104	}
1105	if (height <= 0 || width <= 0 || bytesperline <= 0) {
1106		dprintk(1,
1107			KERN_ERR
1108			"%s: %s - invalid height/width/bpl value (%d|%d|%d)\n",
1109			ZR_DEVNAME(zr), __func__, width, height, bytesperline);
1110		return -EINVAL;
1111	}
1112	if (bytesperline & 3) {
1113		dprintk(1,
1114			KERN_ERR
1115			"%s: %s - bytesperline (%d) must be 4-byte aligned\n",
1116			ZR_DEVNAME(zr), __func__, bytesperline);
1117		return -EINVAL;
1118	}
1119
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;
1126
1127	/* The user should set new window parameters */
1128	zr->overlay_settings.is_set = 0;
1129
1130	return 0;
1131}
1132
1133
1134static int setup_window(struct zoran_fh *fh,
1135			int x,
1136			int y,
1137			int width,
1138			int height,
1139			struct v4l2_clip __user *clips,
1140			unsigned int clipcount,
1141			void __user *bitmap)
1142{
1143	struct zoran *zr = fh->zr;
1144	struct v4l2_clip *vcp = NULL;
1145	int on, end;
1146
1147
1148	if (!zr->vbuf_base) {
1149		dprintk(1,
1150			KERN_ERR
1151			"%s: %s - frame buffer has to be set first\n",
1152			ZR_DEVNAME(zr), __func__);
1153		return -EINVAL;
1154	}
1155
1156	if (!fh->overlay_settings.format) {
1157		dprintk(1,
1158			KERN_ERR
1159			"%s: %s - no overlay format set\n",
1160			ZR_DEVNAME(zr), __func__);
1161		return -EINVAL;
1162	}
1163
1164	if (clipcount > 2048) {
1165		dprintk(1,
1166			KERN_ERR
1167			"%s: %s - invalid clipcount\n",
1168			 ZR_DEVNAME(zr), __func__);
1169		return -EINVAL;
1170	}
1171
1172	/*
1173	 * The video front end needs 4-byte alinged line sizes, we correct that
1174	 * silently here if necessary
1175	 */
1176	if (zr->vbuf_depth == 15 || zr->vbuf_depth == 16) {
1177		end = (x + width) & ~1;	/* round down */
1178		x = (x + 1) & ~1;	/* round up */
1179		width = end - x;
1180	}
1181
1182	if (zr->vbuf_depth == 24) {
1183		end = (x + width) & ~3;	/* round down */
1184		x = (x + 3) & ~3;	/* round up */
1185		width = end - x;
1186	}
1187
1188	if (width > BUZ_MAX_WIDTH)
1189		width = BUZ_MAX_WIDTH;
1190	if (height > BUZ_MAX_HEIGHT)
1191		height = BUZ_MAX_HEIGHT;
1192
1193	/* Check for invalid parameters */
1194	if (width < BUZ_MIN_WIDTH || height < BUZ_MIN_HEIGHT ||
1195	    width > BUZ_MAX_WIDTH || height > BUZ_MAX_HEIGHT) {
1196		dprintk(1,
1197			KERN_ERR
1198			"%s: %s - width = %d or height = %d invalid\n",
1199			ZR_DEVNAME(zr), __func__, width, height);
1200		return -EINVAL;
1201	}
1202
1203	fh->overlay_settings.x = x;
1204	fh->overlay_settings.y = y;
1205	fh->overlay_settings.width = width;
1206	fh->overlay_settings.height = height;
1207	fh->overlay_settings.clipcount = clipcount;
1208
1209	/*
1210	 * If an overlay is running, we have to switch it off
1211	 * and switch it on again in order to get the new settings in effect.
1212	 *
1213	 * We also want to avoid that the overlay mask is written
1214	 * when an overlay is running.
1215	 */
1216
1217	on = zr->v4l_overlay_active && !zr->v4l_memgrab_active &&
1218	    zr->overlay_active != ZORAN_FREE &&
1219	    fh->overlay_active != ZORAN_FREE;
1220	if (on)
1221		zr36057_overlay(zr, 0);
1222
1223	/*
1224	 *   Write the overlay mask if clips are wanted.
1225	 *   We prefer a bitmap.
1226	 */
1227	if (bitmap) {
1228		/* fake value - it just means we want clips */
1229		fh->overlay_settings.clipcount = 1;
1230
1231		if (copy_from_user(fh->overlay_mask, bitmap,
1232				   (width * height + 7) / 8)) {
1233			return -EFAULT;
1234		}
1235	} else if (clipcount) {
1236		/* write our own bitmap from the clips */
1237		vcp = vmalloc(sizeof(struct v4l2_clip) * (clipcount + 4));
1238		if (vcp == NULL) {
1239			dprintk(1,
1240				KERN_ERR
1241				"%s: %s - Alloc of clip mask failed\n",
1242				ZR_DEVNAME(zr), __func__);
1243			return -ENOMEM;
1244		}
1245		if (copy_from_user
1246		    (vcp, clips, sizeof(struct v4l2_clip) * clipcount)) {
1247			vfree(vcp);
1248			return -EFAULT;
1249		}
1250		write_overlay_mask(fh, vcp, clipcount);
1251		vfree(vcp);
1252	}
1253
1254	fh->overlay_settings.is_set = 1;
1255	if (fh->overlay_active != ZORAN_FREE &&
1256	    zr->overlay_active != ZORAN_FREE)
1257		zr->overlay_settings = fh->overlay_settings;
1258
1259	if (on)
1260		zr36057_overlay(zr, 1);
1261
1262	/* Make sure the changes come into effect */
1263	return wait_grab_pending(zr);
1264}
1265
1266static int setup_overlay(struct zoran_fh *fh, int on)
1267{
1268	struct zoran *zr = fh->zr;
1269
1270	/* If there is nothing to do, return immediately */
1271	if ((on && fh->overlay_active != ZORAN_FREE) ||
1272	    (!on && fh->overlay_active == ZORAN_FREE))
1273		return 0;
1274
1275	/* check whether we're touching someone else's overlay */
1276	if (on && zr->overlay_active != ZORAN_FREE &&
1277	    fh->overlay_active == ZORAN_FREE) {
1278		dprintk(1,
1279			KERN_ERR
1280			"%s: %s - overlay is already active for another session\n",
1281			ZR_DEVNAME(zr), __func__);
1282		return -EBUSY;
1283	}
1284	if (!on && zr->overlay_active != ZORAN_FREE &&
1285	    fh->overlay_active == ZORAN_FREE) {
1286		dprintk(1,
1287			KERN_ERR
1288			"%s: %s - you cannot cancel someone else's session\n",
1289			ZR_DEVNAME(zr), __func__);
1290		return -EPERM;
1291	}
1292
1293	if (on == 0) {
1294		zr->overlay_active = fh->overlay_active = ZORAN_FREE;
1295		zr->v4l_overlay_active = 0;
1296		/* When a grab is running, the video simply
1297		 * won't be switched on any more */
1298		if (!zr->v4l_memgrab_active)
1299			zr36057_overlay(zr, 0);
1300		zr->overlay_mask = NULL;
1301	} else {
1302		if (!zr->vbuf_base || !fh->overlay_settings.is_set) {
1303			dprintk(1,
1304				KERN_ERR
1305				"%s: %s - buffer or window not set\n",
1306				ZR_DEVNAME(zr), __func__);
1307			return -EINVAL;
1308		}
1309		if (!fh->overlay_settings.format) {
1310			dprintk(1,
1311				KERN_ERR
1312				"%s: %s - no overlay format set\n",
1313				ZR_DEVNAME(zr), __func__);
1314			return -EINVAL;
1315		}
1316		zr->overlay_active = fh->overlay_active = ZORAN_LOCKED;
1317		zr->v4l_overlay_active = 1;
1318		zr->overlay_mask = fh->overlay_mask;
1319		zr->overlay_settings = fh->overlay_settings;
1320		if (!zr->v4l_memgrab_active)
1321			zr36057_overlay(zr, 1);
1322		/* When a grab is running, the video will be
1323		 * switched on when grab is finished */
1324	}
1325
1326	/* Make sure the changes come into effect */
1327	return wait_grab_pending(zr);
1328}
1329
1330/* get the status of a buffer in the clients buffer queue */
1331static int zoran_v4l2_buffer_status(struct zoran_fh *fh,
1332				    struct v4l2_buffer *buf, int num)
1333{
1334	struct zoran *zr = fh->zr;
1335	unsigned long flags;
1336
1337	buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1338
1339	switch (fh->map_mode) {
1340	case ZORAN_MAP_MODE_RAW:
1341		/* check range */
1342		if (num < 0 || num >= fh->buffers.num_buffers ||
1343		    !fh->buffers.allocated) {
1344			dprintk(1,
1345				KERN_ERR
1346				"%s: %s - wrong number or buffers not allocated\n",
1347				ZR_DEVNAME(zr), __func__);
1348			return -EINVAL;
1349		}
1350
1351		spin_lock_irqsave(&zr->spinlock, flags);
1352		dprintk(3,
1353			KERN_DEBUG
1354			"%s: %s() - raw active=%c, buffer %d: state=%c, map=%c\n",
1355			ZR_DEVNAME(zr), __func__,
1356			"FAL"[fh->buffers.active], num,
1357			"UPMD"[zr->v4l_buffers.buffer[num].state],
1358			fh->buffers.buffer[num].map ? 'Y' : 'N');
1359		spin_unlock_irqrestore(&zr->spinlock, flags);
1360
1361		buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1362		buf->length = fh->buffers.buffer_size;
1363
1364		/* get buffer */
1365		buf->bytesused = fh->buffers.buffer[num].bs.length;
1366		if (fh->buffers.buffer[num].state == BUZ_STATE_DONE ||
1367		    fh->buffers.buffer[num].state == BUZ_STATE_USER) {
1368			buf->sequence = fh->buffers.buffer[num].bs.seq;
1369			buf->flags |= V4L2_BUF_FLAG_DONE;
1370			buf->timestamp = fh->buffers.buffer[num].bs.timestamp;
1371		} else {
1372			buf->flags |= V4L2_BUF_FLAG_QUEUED;
1373		}
1374
1375		if (fh->v4l_settings.height <= BUZ_MAX_HEIGHT / 2)
1376			buf->field = V4L2_FIELD_TOP;
1377		else
1378			buf->field = V4L2_FIELD_INTERLACED;
1379
1380		break;
1381
1382	case ZORAN_MAP_MODE_JPG_REC:
1383	case ZORAN_MAP_MODE_JPG_PLAY:
1384
1385		/* check range */
1386		if (num < 0 || num >= fh->buffers.num_buffers ||
1387		    !fh->buffers.allocated) {
1388			dprintk(1,
1389				KERN_ERR
1390				"%s: %s - wrong number or buffers not allocated\n",
1391				ZR_DEVNAME(zr), __func__);
1392			return -EINVAL;
1393		}
1394
1395		buf->type = (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?
1396			      V4L2_BUF_TYPE_VIDEO_CAPTURE :
1397			      V4L2_BUF_TYPE_VIDEO_OUTPUT;
1398		buf->length = fh->buffers.buffer_size;
1399
1400		/* these variables are only written after frame has been captured */
1401		if (fh->buffers.buffer[num].state == BUZ_STATE_DONE ||
1402		    fh->buffers.buffer[num].state == BUZ_STATE_USER) {
1403			buf->sequence = fh->buffers.buffer[num].bs.seq;
1404			buf->timestamp = fh->buffers.buffer[num].bs.timestamp;
1405			buf->bytesused = fh->buffers.buffer[num].bs.length;
1406			buf->flags |= V4L2_BUF_FLAG_DONE;
1407		} else {
1408			buf->flags |= V4L2_BUF_FLAG_QUEUED;
1409		}
1410
1411		/* which fields are these? */
1412		if (fh->jpg_settings.TmpDcm != 1)
1413			buf->field = fh->jpg_settings.odd_even ?
1414				V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
1415		else
1416			buf->field = fh->jpg_settings.odd_even ?
1417				V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT;
1418
1419		break;
1420
1421	default:
1422
1423		dprintk(5,
1424			KERN_ERR
1425			"%s: %s - invalid buffer type|map_mode (%d|%d)\n",
1426			ZR_DEVNAME(zr), __func__, buf->type, fh->map_mode);
1427		return -EINVAL;
1428	}
1429
1430	buf->memory = V4L2_MEMORY_MMAP;
1431	buf->index = num;
1432	buf->m.offset = buf->length * num;
1433
1434	return 0;
1435}
1436
1437static int
1438zoran_set_norm (struct zoran *zr,
1439		v4l2_std_id norm)
1440{
1441	int on;
1442
1443	if (zr->v4l_buffers.active != ZORAN_FREE ||
1444	    zr->jpg_buffers.active != ZORAN_FREE) {
1445		dprintk(1,
1446			KERN_WARNING
1447			"%s: %s called while in playback/capture mode\n",
1448			ZR_DEVNAME(zr), __func__);
1449		return -EBUSY;
1450	}
1451
1452	if (!(norm & zr->card.norms)) {
1453		dprintk(1,
1454			KERN_ERR "%s: %s - unsupported norm %llx\n",
1455			ZR_DEVNAME(zr), __func__, norm);
1456		return -EINVAL;
1457	}
1458
1459	if (norm & V4L2_STD_SECAM)
1460		zr->timing = zr->card.tvn[2];
1461	else if (norm & V4L2_STD_NTSC)
1462		zr->timing = zr->card.tvn[1];
1463	else
1464		zr->timing = zr->card.tvn[0];
1465
1466	/* We switch overlay off and on since a change in the
1467	 * norm needs different VFE settings */
1468	on = zr->overlay_active && !zr->v4l_memgrab_active;
1469	if (on)
1470		zr36057_overlay(zr, 0);
1471
1472	decoder_call(zr, video, s_std, norm);
1473	encoder_call(zr, video, s_std_output, norm);
1474
1475	if (on)
1476		zr36057_overlay(zr, 1);
1477
1478	/* Make sure the changes come into effect */
1479	zr->norm = norm;
1480
1481	return 0;
1482}
1483
1484static int
1485zoran_set_input (struct zoran *zr,
1486		 int           input)
1487{
1488	if (input == zr->input) {
1489		return 0;
1490	}
1491
1492	if (zr->v4l_buffers.active != ZORAN_FREE ||
1493	    zr->jpg_buffers.active != ZORAN_FREE) {
1494		dprintk(1,
1495			KERN_WARNING
1496			"%s: %s called while in playback/capture mode\n",
1497			ZR_DEVNAME(zr), __func__);
1498		return -EBUSY;
1499	}
1500
1501	if (input < 0 || input >= zr->card.inputs) {
1502		dprintk(1,
1503			KERN_ERR
1504			"%s: %s - unnsupported input %d\n",
1505			ZR_DEVNAME(zr), __func__, input);
1506		return -EINVAL;
1507	}
1508
1509	zr->input = input;
1510
1511	decoder_call(zr, video, s_routing,
1512			zr->card.input[input].muxsel, 0, 0);
1513
1514	return 0;
1515}
1516
1517/*
1518 *   ioctl routine
1519 */
1520
1521static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability *cap)
1522{
1523	struct zoran_fh *fh = __fh;
1524	struct zoran *zr = fh->zr;
1525
1526	memset(cap, 0, sizeof(*cap));
1527	strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1);
1528	strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);
1529	snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
1530		 pci_name(zr->pci_dev));
1531	cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE |
1532			   V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OVERLAY;
1533	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1534	return 0;
1535}
1536
1537static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag)
1538{
1539	unsigned int num, i;
1540
1541	for (num = i = 0; i < NUM_FORMATS; i++) {
1542		if (zoran_formats[i].flags & flag && num++ == fmt->index) {
1543			strncpy(fmt->description, zoran_formats[i].name,
1544				sizeof(fmt->description) - 1);
1545			/* fmt struct pre-zeroed, so adding '\0' not needed */
1546			fmt->pixelformat = zoran_formats[i].fourcc;
1547			if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
1548				fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
1549			return 0;
1550		}
1551	}
1552	return -EINVAL;
1553}
1554
1555static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh,
1556					    struct v4l2_fmtdesc *f)
1557{
1558	struct zoran_fh *fh = __fh;
1559	struct zoran *zr = fh->zr;
1560
1561	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE);
1562}
1563
1564static int zoran_enum_fmt_vid_out(struct file *file, void *__fh,
1565					    struct v4l2_fmtdesc *f)
1566{
1567	struct zoran_fh *fh = __fh;
1568	struct zoran *zr = fh->zr;
1569
1570	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_PLAYBACK);
1571}
1572
1573static int zoran_enum_fmt_vid_overlay(struct file *file, void *__fh,
1574					    struct v4l2_fmtdesc *f)
1575{
1576	struct zoran_fh *fh = __fh;
1577	struct zoran *zr = fh->zr;
1578
1579	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_OVERLAY);
1580}
1581
1582static int zoran_g_fmt_vid_out(struct file *file, void *__fh,
1583					struct v4l2_format *fmt)
1584{
1585	struct zoran_fh *fh = __fh;
1586	struct zoran *zr = fh->zr;
1587
1588	mutex_lock(&zr->resource_lock);
1589
1590	fmt->fmt.pix.width = fh->jpg_settings.img_width / fh->jpg_settings.HorDcm;
1591	fmt->fmt.pix.height = fh->jpg_settings.img_height * 2 /
1592		(fh->jpg_settings.VerDcm * fh->jpg_settings.TmpDcm);
1593	fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
1594	fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1595	if (fh->jpg_settings.TmpDcm == 1)
1596		fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1597				V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
1598	else
1599		fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1600				V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1601	fmt->fmt.pix.bytesperline = 0;
1602	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1603
1604	mutex_unlock(&zr->resource_lock);
1605	return 0;
1606}
1607
1608static int zoran_g_fmt_vid_cap(struct file *file, void *__fh,
1609					struct v4l2_format *fmt)
1610{
1611	struct zoran_fh *fh = __fh;
1612	struct zoran *zr = fh->zr;
1613
1614	if (fh->map_mode != ZORAN_MAP_MODE_RAW)
1615		return zoran_g_fmt_vid_out(file, fh, fmt);
1616
1617	mutex_lock(&zr->resource_lock);
1618	fmt->fmt.pix.width = fh->v4l_settings.width;
1619	fmt->fmt.pix.height = fh->v4l_settings.height;
1620	fmt->fmt.pix.sizeimage = fh->v4l_settings.bytesperline *
1621					fh->v4l_settings.height;
1622	fmt->fmt.pix.pixelformat = fh->v4l_settings.format->fourcc;
1623	fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;
1624	fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;
1625	if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))
1626		fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
1627	else
1628		fmt->fmt.pix.field = V4L2_FIELD_TOP;
1629	mutex_unlock(&zr->resource_lock);
1630	return 0;
1631}
1632
1633static int zoran_g_fmt_vid_overlay(struct file *file, void *__fh,
1634					struct v4l2_format *fmt)
1635{
1636	struct zoran_fh *fh = __fh;
1637	struct zoran *zr = fh->zr;
1638
1639	mutex_lock(&zr->resource_lock);
1640
1641	fmt->fmt.win.w.left = fh->overlay_settings.x;
1642	fmt->fmt.win.w.top = fh->overlay_settings.y;
1643	fmt->fmt.win.w.width = fh->overlay_settings.width;
1644	fmt->fmt.win.w.height = fh->overlay_settings.height;
1645	if (fh->overlay_settings.width * 2 > BUZ_MAX_HEIGHT)
1646		fmt->fmt.win.field = V4L2_FIELD_INTERLACED;
1647	else
1648		fmt->fmt.win.field = V4L2_FIELD_TOP;
1649
1650	mutex_unlock(&zr->resource_lock);
1651	return 0;
1652}
1653
1654static int zoran_try_fmt_vid_overlay(struct file *file, void *__fh,
1655					struct v4l2_format *fmt)
1656{
1657	struct zoran_fh *fh = __fh;
1658	struct zoran *zr = fh->zr;
1659
1660	mutex_lock(&zr->resource_lock);
1661
1662	if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH)
1663		fmt->fmt.win.w.width = BUZ_MAX_WIDTH;
1664	if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH)
1665		fmt->fmt.win.w.width = BUZ_MIN_WIDTH;
1666	if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT)
1667		fmt->fmt.win.w.height = BUZ_MAX_HEIGHT;
1668	if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT)
1669		fmt->fmt.win.w.height = BUZ_MIN_HEIGHT;
1670
1671	mutex_unlock(&zr->resource_lock);
1672	return 0;
1673}
1674
1675static int zoran_try_fmt_vid_out(struct file *file, void *__fh,
1676					struct v4l2_format *fmt)
1677{
1678	struct zoran_fh *fh = __fh;
1679	struct zoran *zr = fh->zr;
1680	struct zoran_jpg_settings settings;
1681	int res = 0;
1682
1683	if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1684		return -EINVAL;
1685
1686	mutex_lock(&zr->resource_lock);
1687	settings = fh->jpg_settings;
1688
1689	/* we actually need to set 'real' parameters now */
1690	if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT)
1691		settings.TmpDcm = 1;
1692	else
1693		settings.TmpDcm = 2;
1694	settings.decimation = 0;
1695	if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)
1696		settings.VerDcm = 2;
1697	else
1698		settings.VerDcm = 1;
1699	if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)
1700		settings.HorDcm = 4;
1701	else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)
1702		settings.HorDcm = 2;
1703	else
1704		settings.HorDcm = 1;
1705	if (settings.TmpDcm == 1)
1706		settings.field_per_buff = 2;
1707	else
1708		settings.field_per_buff = 1;
1709
1710	if (settings.HorDcm > 1) {
1711		settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
1712		settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
1713	} else {
1714		settings.img_x = 0;
1715		settings.img_width = BUZ_MAX_WIDTH;
1716	}
1717
1718	/* check */
1719	res = zoran_check_jpg_settings(zr, &settings, 1);
1720	if (res)
1721		goto tryfmt_unlock_and_return;
1722
1723	/* tell the user what we actually did */
1724	fmt->fmt.pix.width = settings.img_width / settings.HorDcm;
1725	fmt->fmt.pix.height = settings.img_height * 2 /
1726		(settings.TmpDcm * settings.VerDcm);
1727	if (settings.TmpDcm == 1)
1728		fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1729				V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
1730	else
1731		fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1732				V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1733
1734	fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings);
1735	fmt->fmt.pix.bytesperline = 0;
1736	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1737tryfmt_unlock_and_return:
1738	mutex_unlock(&zr->resource_lock);
1739	return res;
1740}
1741
1742static int zoran_try_fmt_vid_cap(struct file *file, void *__fh,
1743					struct v4l2_format *fmt)
1744{
1745	struct zoran_fh *fh = __fh;
1746	struct zoran *zr = fh->zr;
1747	int bpp;
1748	int i;
1749
1750	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
1751		return zoran_try_fmt_vid_out(file, fh, fmt);
1752
1753	mutex_lock(&zr->resource_lock);
1754
1755	for (i = 0; i < NUM_FORMATS; i++)
1756		if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat)
1757			break;
1758
1759	if (i == NUM_FORMATS) {
1760		mutex_unlock(&zr->resource_lock);
1761		return -EINVAL;
1762	}
1763
1764	bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8);
1765	v4l_bound_align_image(
1766		&fmt->fmt.pix.width, BUZ_MIN_WIDTH, BUZ_MAX_WIDTH, bpp == 2 ? 1 : 2,
1767		&fmt->fmt.pix.height, BUZ_MIN_HEIGHT, BUZ_MAX_HEIGHT, 0, 0);
1768	mutex_unlock(&zr->resource_lock);
1769
1770	return 0;
1771}
1772
1773static int zoran_s_fmt_vid_overlay(struct file *file, void *__fh,
1774					struct v4l2_format *fmt)
1775{
1776	struct zoran_fh *fh = __fh;
1777	struct zoran *zr = fh->zr;
1778	int res;
1779
1780	dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
1781			fmt->fmt.win.w.left, fmt->fmt.win.w.top,
1782			fmt->fmt.win.w.width,
1783			fmt->fmt.win.w.height,
1784			fmt->fmt.win.clipcount,
1785			fmt->fmt.win.bitmap);
1786	mutex_lock(&zr->resource_lock);
1787	res = setup_window(fh, fmt->fmt.win.w.left, fmt->fmt.win.w.top,
1788			   fmt->fmt.win.w.width, fmt->fmt.win.w.height,
1789			   (struct v4l2_clip __user *)fmt->fmt.win.clips,
1790			   fmt->fmt.win.clipcount, fmt->fmt.win.bitmap);
1791	mutex_unlock(&zr->resource_lock);
1792	return res;
1793}
1794
1795static int zoran_s_fmt_vid_out(struct file *file, void *__fh,
1796					struct v4l2_format *fmt)
1797{
1798	struct zoran_fh *fh = __fh;
1799	struct zoran *zr = fh->zr;
1800	__le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat);
1801	struct zoran_jpg_settings settings;
1802	int res = 0;
1803
1804	dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
1805			fmt->fmt.pix.width, fmt->fmt.pix.height,
1806			fmt->fmt.pix.pixelformat,
1807			(char *) &printformat);
1808	if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1809		return -EINVAL;
1810
1811	mutex_lock(&zr->resource_lock);
1812
1813	if (fh->buffers.allocated) {
1814		dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",
1815			ZR_DEVNAME(zr));
1816		res = -EBUSY;
1817		goto sfmtjpg_unlock_and_return;
1818	}
1819
1820	settings = fh->jpg_settings;
1821
1822	/* we actually need to set 'real' parameters now */
1823	if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT)
1824		settings.TmpDcm = 1;
1825	else
1826		settings.TmpDcm = 2;
1827	settings.decimation = 0;
1828	if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)
1829		settings.VerDcm = 2;
1830	else
1831		settings.VerDcm = 1;
1832	if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)
1833		settings.HorDcm = 4;
1834	else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)
1835		settings.HorDcm = 2;
1836	else
1837		settings.HorDcm = 1;
1838	if (settings.TmpDcm == 1)
1839		settings.field_per_buff = 2;
1840	else
1841		settings.field_per_buff = 1;
1842
1843	if (settings.HorDcm > 1) {
1844		settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
1845		settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
1846	} else {
1847		settings.img_x = 0;
1848		settings.img_width = BUZ_MAX_WIDTH;
1849	}
1850
1851	/* check */
1852	res = zoran_check_jpg_settings(zr, &settings, 0);
1853	if (res)
1854		goto sfmtjpg_unlock_and_return;
1855
1856	/* it's ok, so set them */
1857	fh->jpg_settings = settings;
1858
1859	map_mode_jpg(fh, fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT);
1860	fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
1861
1862	/* tell the user what we actually did */
1863	fmt->fmt.pix.width = settings.img_width / settings.HorDcm;
1864	fmt->fmt.pix.height = settings.img_height * 2 /
1865		(settings.TmpDcm * settings.VerDcm);
1866	if (settings.TmpDcm == 1)
1867		fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1868				V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
1869	else
1870		fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1871				V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1872	fmt->fmt.pix.bytesperline = 0;
1873	fmt->fmt.pix.sizeimage = fh->buffers.buffer_size;
1874	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1875
1876sfmtjpg_unlock_and_return:
1877	mutex_unlock(&zr->resource_lock);
1878	return res;
1879}
1880
1881static int zoran_s_fmt_vid_cap(struct file *file, void *__fh,
1882					struct v4l2_format *fmt)
1883{
1884	struct zoran_fh *fh = __fh;
1885	struct zoran *zr = fh->zr;
1886	int i;
1887	int res = 0;
1888
1889	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
1890		return zoran_s_fmt_vid_out(file, fh, fmt);
1891
1892	for (i = 0; i < NUM_FORMATS; i++)
1893		if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc)
1894			break;
1895	if (i == NUM_FORMATS) {
1896		dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",
1897			ZR_DEVNAME(zr), fmt->fmt.pix.pixelformat);
1898		return -EINVAL;
1899	}
1900
1901	mutex_lock(&zr->resource_lock);
1902
1903	if ((fh->map_mode != ZORAN_MAP_MODE_RAW && fh->buffers.allocated) ||
1904	    fh->buffers.active != ZORAN_FREE) {
1905		dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",
1906				ZR_DEVNAME(zr));
1907		res = -EBUSY;
1908		goto sfmtv4l_unlock_and_return;
1909	}
1910	if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
1911		fmt->fmt.pix.height = BUZ_MAX_HEIGHT;
1912	if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
1913		fmt->fmt.pix.width = BUZ_MAX_WIDTH;
1914
1915	map_mode_raw(fh);
1916
1917	res = zoran_v4l_set_format(fh, fmt->fmt.pix.width, fmt->fmt.pix.height,
1918				   &zoran_formats[i]);
1919	if (res)
1920		goto sfmtv4l_unlock_and_return;
1921
1922	/* tell the user the results/missing stuff */
1923	fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;
1924	fmt->fmt.pix.sizeimage = fh->v4l_settings.height * fh->v4l_settings.bytesperline;
1925	fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;
1926	if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))
1927		fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
1928	else
1929		fmt->fmt.pix.field = V4L2_FIELD_TOP;
1930
1931sfmtv4l_unlock_and_return:
1932	mutex_unlock(&zr->resource_lock);
1933	return res;
1934}
1935
1936static int zoran_g_fbuf(struct file *file, void *__fh,
1937		struct v4l2_framebuffer *fb)
1938{
1939	struct zoran_fh *fh = __fh;
1940	struct zoran *zr = fh->zr;
1941
1942	memset(fb, 0, sizeof(*fb));
1943	mutex_lock(&zr->resource_lock);
1944	fb->base = zr->vbuf_base;
1945	fb->fmt.width = zr->vbuf_width;
1946	fb->fmt.height = zr->vbuf_height;
1947	if (zr->overlay_settings.format)
1948		fb->fmt.pixelformat = fh->overlay_settings.format->fourcc;
1949	fb->fmt.bytesperline = zr->vbuf_bytesperline;
1950	mutex_unlock(&zr->resource_lock);
1951	fb->fmt.colorspace = V4L2_COLORSPACE_SRGB;
1952	fb->fmt.field = V4L2_FIELD_INTERLACED;
1953	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
1954
1955	return 0;
1956}
1957
1958static int zoran_s_fbuf(struct file *file, void *__fh,
1959		const struct v4l2_framebuffer *fb)
1960{
1961	struct zoran_fh *fh = __fh;
1962	struct zoran *zr = fh->zr;
1963	int i, res = 0;
1964	__le32 printformat = __cpu_to_le32(fb->fmt.pixelformat);
1965
1966	for (i = 0; i < NUM_FORMATS; i++)
1967		if (zoran_formats[i].fourcc == fb->fmt.pixelformat)
1968			break;
1969	if (i == NUM_FORMATS) {
1970		dprintk(1, KERN_ERR "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
1971			ZR_DEVNAME(zr), fb->fmt.pixelformat,
1972			(char *)&printformat);
1973		return -EINVAL;
1974	}
1975
1976	mutex_lock(&zr->resource_lock);
1977	res = setup_fbuffer(fh, fb->base, &zoran_formats[i], fb->fmt.width,
1978			    fb->fmt.height, fb->fmt.bytesperline);
1979	mutex_unlock(&zr->resource_lock);
1980
1981	return res;
1982}
1983
1984static int zoran_overlay(struct file *file, void *__fh, unsigned int on)
1985{
1986	struct zoran_fh *fh = __fh;
1987	struct zoran *zr = fh->zr;
1988	int res;
1989
1990	mutex_lock(&zr->resource_lock);
1991	res = setup_overlay(fh, on);
1992	mutex_unlock(&zr->resource_lock);
1993
1994	return res;
1995}
1996
1997static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type);
1998
1999static int zoran_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *req)
2000{
2001	struct zoran_fh *fh = __fh;
2002	struct zoran *zr = fh->zr;
2003	int res = 0;
2004
2005	if (req->memory != V4L2_MEMORY_MMAP) {
2006		dprintk(2,
2007				KERN_ERR
2008				"%s: only MEMORY_MMAP capture is supported, not %d\n",
2009				ZR_DEVNAME(zr), req->memory);
2010		return -EINVAL;
2011	}
2012
2013	if (req->count == 0)
2014		return zoran_streamoff(file, fh, req->type);
2015
2016	mutex_lock(&zr->resource_lock);
2017	if (fh->buffers.allocated) {
2018		dprintk(2,
2019				KERN_ERR
2020				"%s: VIDIOC_REQBUFS - buffers already allocated\n",
2021				ZR_DEVNAME(zr));
2022		res = -EBUSY;
2023		goto v4l2reqbuf_unlock_and_return;
2024	}
2025
2026	if (fh->map_mode == ZORAN_MAP_MODE_RAW &&
2027	    req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2028		/* control user input */
2029		if (req->count < 2)
2030			req->count = 2;
2031		if (req->count > v4l_nbufs)
2032			req->count = v4l_nbufs;
2033
2034		/* The next mmap will map the V4L buffers */
2035		map_mode_raw(fh);
2036		fh->buffers.num_buffers = req->count;
2037
2038		if (v4l_fbuffer_alloc(fh)) {
2039			res = -ENOMEM;
2040			goto v4l2reqbuf_unlock_and_return;
2041		}
2042	} else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC ||
2043		   fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
2044		/* we need to calculate size ourselves now */
2045		if (req->count < 4)
2046			req->count = 4;
2047		if (req->count > jpg_nbufs)
2048			req->count = jpg_nbufs;
2049
2050		/* The next mmap will map the MJPEG buffers */
2051		map_mode_jpg(fh, req->type == V4L2_BUF_TYPE_VIDEO_OUTPUT);
2052		fh->buffers.num_buffers = req->count;
2053		fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
2054
2055		if (jpg_fbuffer_alloc(fh)) {
2056			res = -ENOMEM;
2057			goto v4l2reqbuf_unlock_and_return;
2058		}
2059	} else {
2060		dprintk(1,
2061				KERN_ERR
2062				"%s: VIDIOC_REQBUFS - unknown type %d\n",
2063				ZR_DEVNAME(zr), req->type);
2064		res = -EINVAL;
2065		goto v4l2reqbuf_unlock_and_return;
2066	}
2067v4l2reqbuf_unlock_and_return:
2068	mutex_unlock(&zr->resource_lock);
2069
2070	return res;
2071}
2072
2073static int zoran_querybuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
2074{
2075	struct zoran_fh *fh = __fh;
2076	struct zoran *zr = fh->zr;
2077	int res;
2078
2079	mutex_lock(&zr->resource_lock);
2080	res = zoran_v4l2_buffer_status(fh, buf, buf->index);
2081	mutex_unlock(&zr->resource_lock);
2082
2083	return res;
2084}
2085
2086static int zoran_qbuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
2087{
2088	struct zoran_fh *fh = __fh;
2089	struct zoran *zr = fh->zr;
2090	int res = 0, codec_mode, buf_type;
2091
2092	mutex_lock(&zr->resource_lock);
2093
2094	switch (fh->map_mode) {
2095	case ZORAN_MAP_MODE_RAW:
2096		if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2097			dprintk(1, KERN_ERR
2098				"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2099				ZR_DEVNAME(zr), buf->type, fh->map_mode);
2100			res = -EINVAL;
2101			goto qbuf_unlock_and_return;
2102		}
2103
2104		res = zoran_v4l_queue_frame(fh, buf->index);
2105		if (res)
2106			goto qbuf_unlock_and_return;
2107		if (!zr->v4l_memgrab_active && fh->buffers.active == ZORAN_LOCKED)
2108			zr36057_set_memgrab(zr, 1);
2109		break;
2110
2111	case ZORAN_MAP_MODE_JPG_REC:
2112	case ZORAN_MAP_MODE_JPG_PLAY:
2113		if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
2114			buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2115			codec_mode = BUZ_MODE_MOTION_DECOMPRESS;
2116		} else {
2117			buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2118			codec_mode = BUZ_MODE_MOTION_COMPRESS;
2119		}
2120
2121		if (buf->type != buf_type) {
2122			dprintk(1, KERN_ERR
2123				"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2124				ZR_DEVNAME(zr), buf->type, fh->map_mode);
2125			res = -EINVAL;
2126			goto qbuf_unlock_and_return;
2127		}
2128
2129		res = zoran_jpg_queue_frame(fh, buf->index, codec_mode);
2130		if (res != 0)
2131			goto qbuf_unlock_and_return;
2132		if (zr->codec_mode == BUZ_MODE_IDLE &&
2133		    fh->buffers.active == ZORAN_LOCKED)
2134			zr36057_enable_jpg(zr, codec_mode);
2135
2136		break;
2137
2138	default:
2139		dprintk(1, KERN_ERR
2140			"%s: VIDIOC_QBUF - unsupported type %d\n",
2141			ZR_DEVNAME(zr), buf->type);
2142		res = -EINVAL;
2143		break;
2144	}
2145qbuf_unlock_and_return:
2146	mutex_unlock(&zr->resource_lock);
2147
2148	return res;
2149}
2150
2151static int zoran_dqbuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
2152{
2153	struct zoran_fh *fh = __fh;
2154	struct zoran *zr = fh->zr;
2155	int res = 0, buf_type, num = -1;	/* compiler borks here (?) */
2156
2157	mutex_lock(&zr->resource_lock);
2158
2159	switch (fh->map_mode) {
2160	case ZORAN_MAP_MODE_RAW:
2161		if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2162			dprintk(1, KERN_ERR
2163				"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2164				ZR_DEVNAME(zr), buf->type, fh->map_mode);
2165			res = -EINVAL;
2166			goto dqbuf_unlock_and_return;
2167		}
2168
2169		num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
2170		if (file->f_flags & O_NONBLOCK &&
2171		    zr->v4l_buffers.buffer[num].state != BUZ_STATE_DONE) {
2172			res = -EAGAIN;
2173			goto dqbuf_unlock_and_return;
2174		}
2175		res = v4l_sync(fh, num);
2176		if (res)
2177			goto dqbuf_unlock_and_return;
2178		zr->v4l_sync_tail++;
2179		res = zoran_v4l2_buffer_status(fh, buf, num);
2180		break;
2181
2182	case ZORAN_MAP_MODE_JPG_REC:
2183	case ZORAN_MAP_MODE_JPG_PLAY:
2184	{
2185		struct zoran_sync bs;
2186
2187		if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY)
2188			buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2189		else
2190			buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2191
2192		if (buf->type != buf_type) {
2193			dprintk(1, KERN_ERR
2194				"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2195				ZR_DEVNAME(zr), buf->type, fh->map_mode);
2196			res = -EINVAL;
2197			goto dqbuf_unlock_and_return;
2198		}
2199
2200		num = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
2201
2202		if (file->f_flags & O_NONBLOCK &&
2203		    zr->jpg_buffers.buffer[num].state != BUZ_STATE_DONE) {
2204			res = -EAGAIN;
2205			goto dqbuf_unlock_and_return;
2206		}
2207		bs.frame = 0; /* suppress compiler warning */
2208		res = jpg_sync(fh, &bs);
2209		if (res)
2210			goto dqbuf_unlock_and_return;
2211		res = zoran_v4l2_buffer_status(fh, buf, bs.frame);
2212		break;
2213	}
2214
2215	default:
2216		dprintk(1, KERN_ERR
2217			"%s: VIDIOC_DQBUF - unsupported type %d\n",
2218			ZR_DEVNAME(zr), buf->type);
2219		res = -EINVAL;
2220		break;
2221	}
2222dqbuf_unlock_and_return:
2223	mutex_unlock(&zr->resource_lock);
2224
2225	return res;
2226}
2227
2228static int zoran_streamon(struct file *file, void *__fh, enum v4l2_buf_type type)
2229{
2230	struct zoran_fh *fh = __fh;
2231	struct zoran *zr = fh->zr;
2232	int res = 0;
2233
2234	mutex_lock(&zr->resource_lock);
2235
2236	switch (fh->map_mode) {
2237	case ZORAN_MAP_MODE_RAW:	/* raw capture */
2238		if (zr->v4l_buffers.active != ZORAN_ACTIVE ||
2239		    fh->buffers.active != ZORAN_ACTIVE) {
2240			res = -EBUSY;
2241			goto strmon_unlock_and_return;
2242		}
2243
2244		zr->v4l_buffers.active = fh->buffers.active = ZORAN_LOCKED;
2245		zr->v4l_settings = fh->v4l_settings;
2246
2247		zr->v4l_sync_tail = zr->v4l_pend_tail;
2248		if (!zr->v4l_memgrab_active &&
2249		    zr->v4l_pend_head != zr->v4l_pend_tail) {
2250			zr36057_set_memgrab(zr, 1);
2251		}
2252		break;
2253
2254	case ZORAN_MAP_MODE_JPG_REC:
2255	case ZORAN_MAP_MODE_JPG_PLAY:
2256		/* what is the codec mode right now? */
2257		if (zr->jpg_buffers.active != ZORAN_ACTIVE ||
2258		    fh->buffers.active != ZORAN_ACTIVE) {
2259			res = -EBUSY;
2260			goto strmon_unlock_and_return;
2261		}
2262
2263		zr->jpg_buffers.active = fh->buffers.active = ZORAN_LOCKED;
2264
2265		if (zr->jpg_que_head != zr->jpg_que_tail) {
2266			/* Start the jpeg codec when the first frame is queued  */
2267			jpeg_start(zr);
2268		}
2269		break;
2270
2271	default:
2272		dprintk(1,
2273			KERN_ERR
2274			"%s: VIDIOC_STREAMON - invalid map mode %d\n",
2275			ZR_DEVNAME(zr), fh->map_mode);
2276		res = -EINVAL;
2277		break;
2278	}
2279strmon_unlock_and_return:
2280	mutex_unlock(&zr->resource_lock);
2281
2282	return res;
2283}
2284
2285static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type)
2286{
2287	struct zoran_fh *fh = __fh;
2288	struct zoran *zr = fh->zr;
2289	int i, res = 0;
2290	unsigned long flags;
2291
2292	mutex_lock(&zr->resource_lock);
2293
2294	switch (fh->map_mode) {
2295	case ZORAN_MAP_MODE_RAW:	/* raw capture */
2296		if (fh->buffers.active == ZORAN_FREE &&
2297		    zr->v4l_buffers.active != ZORAN_FREE) {
2298			res = -EPERM;	/* stay off other's settings! */
2299			goto strmoff_unlock_and_return;
2300		}
2301		if (zr->v4l_buffers.active == ZORAN_FREE)
2302			goto strmoff_unlock_and_return;
2303
2304		spin_lock_irqsave(&zr->spinlock, flags);
2305		/* unload capture */
2306		if (zr->v4l_memgrab_active) {
2307
2308			zr36057_set_memgrab(zr, 0);
2309		}
2310
2311		for (i = 0; i < fh->buffers.num_buffers; i++)
2312			zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;
2313		fh->buffers = zr->v4l_buffers;
2314
2315		zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE;
2316
2317		zr->v4l_grab_seq = 0;
2318		zr->v4l_pend_head = zr->v4l_pend_tail = 0;
2319		zr->v4l_sync_tail = 0;
2320
2321		spin_unlock_irqrestore(&zr->spinlock, flags);
2322
2323		break;
2324
2325	case ZORAN_MAP_MODE_JPG_REC:
2326	case ZORAN_MAP_MODE_JPG_PLAY:
2327		if (fh->buffers.active == ZORAN_FREE &&
2328		    zr->jpg_buffers.active != ZORAN_FREE) {
2329			res = -EPERM;	/* stay off other's settings! */
2330			goto strmoff_unlock_and_return;
2331		}
2332		if (zr->jpg_buffers.active == ZORAN_FREE)
2333			goto strmoff_unlock_and_return;
2334
2335		res = jpg_qbuf(fh, -1,
2336			     (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?
2337			     BUZ_MODE_MOTION_COMPRESS :
2338			     BUZ_MODE_MOTION_DECOMPRESS);
2339		if (res)
2340			goto strmoff_unlock_and_return;
2341		break;
2342	default:
2343		dprintk(1, KERN_ERR
2344			"%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
2345			ZR_DEVNAME(zr), fh->map_mode);
2346		res = -EINVAL;
2347		break;
2348	}
2349strmoff_unlock_and_return:
2350	mutex_unlock(&zr->resource_lock);
2351
2352	return res;
2353}
2354
2355static int zoran_queryctrl(struct file *file, void *__fh,
2356					struct v4l2_queryctrl *ctrl)
2357{
2358	struct zoran_fh *fh = __fh;
2359	struct zoran *zr = fh->zr;
2360
2361	/* we only support hue/saturation/contrast/brightness */
2362	if (ctrl->id < V4L2_CID_BRIGHTNESS ||
2363	    ctrl->id > V4L2_CID_HUE)
2364		return -EINVAL;
2365
2366	decoder_call(zr, core, queryctrl, ctrl);
2367
2368	return 0;
2369}
2370
2371static int zoran_g_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl)
2372{
2373	struct zoran_fh *fh = __fh;
2374	struct zoran *zr = fh->zr;
2375
2376	/* we only support hue/saturation/contrast/brightness */
2377	if (ctrl->id < V4L2_CID_BRIGHTNESS ||
2378	    ctrl->id > V4L2_CID_HUE)
2379		return -EINVAL;
2380
2381	mutex_lock(&zr->resource_lock);
2382	decoder_call(zr, core, g_ctrl, ctrl);
2383	mutex_unlock(&zr->resource_lock);
2384
2385	return 0;
2386}
2387
2388static int zoran_s_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl)
2389{
2390	struct zoran_fh *fh = __fh;
2391	struct zoran *zr = fh->zr;
2392
2393	/* we only support hue/saturation/contrast/brightness */
2394	if (ctrl->id < V4L2_CID_BRIGHTNESS ||
2395	    ctrl->id > V4L2_CID_HUE)
2396		return -EINVAL;
2397
2398	mutex_lock(&zr->resource_lock);
2399	decoder_call(zr, core, s_ctrl, ctrl);
2400	mutex_unlock(&zr->resource_lock);
2401
2402	return 0;
2403}
2404
2405static int zoran_g_std(struct file *file, void *__fh, v4l2_std_id *std)
2406{
2407	struct zoran_fh *fh = __fh;
2408	struct zoran *zr = fh->zr;
2409
2410	mutex_lock(&zr->resource_lock);
2411	*std = zr->norm;
2412	mutex_unlock(&zr->resource_lock);
2413	return 0;
2414}
2415
2416static int zoran_s_std(struct file *file, void *__fh, v4l2_std_id std)
2417{
2418	struct zoran_fh *fh = __fh;
2419	struct zoran *zr = fh->zr;
2420	int res = 0;
2421
2422	mutex_lock(&zr->resource_lock);
2423	res = zoran_set_norm(zr, std);
2424	if (res)
2425		goto sstd_unlock_and_return;
2426
2427	res = wait_grab_pending(zr);
2428sstd_unlock_and_return:
2429	mutex_unlock(&zr->resource_lock);
2430	return res;
2431}
2432
2433static int zoran_enum_input(struct file *file, void *__fh,
2434				 struct v4l2_input *inp)
2435{
2436	struct zoran_fh *fh = __fh;
2437	struct zoran *zr = fh->zr;
2438
2439	if (inp->index >= zr->card.inputs)
2440		return -EINVAL;
2441
2442	strncpy(inp->name, zr->card.input[inp->index].name,
2443		sizeof(inp->name) - 1);
2444	inp->type = V4L2_INPUT_TYPE_CAMERA;
2445	inp->std = V4L2_STD_ALL;
2446
2447	/* Get status of video decoder */
2448	mutex_lock(&zr->resource_lock);
2449	decoder_call(zr, video, g_input_status, &inp->status);
2450	mutex_unlock(&zr->resource_lock);
2451	return 0;
2452}
2453
2454static int zoran_g_input(struct file *file, void *__fh, unsigned int *input)
2455{
2456	struct zoran_fh *fh = __fh;
2457	struct zoran *zr = fh->zr;
2458
2459	mutex_lock(&zr->resource_lock);
2460	*input = zr->input;
2461	mutex_unlock(&zr->resource_lock);
2462
2463	return 0;
2464}
2465
2466static int zoran_s_input(struct file *file, void *__fh, unsigned int input)
2467{
2468	struct zoran_fh *fh = __fh;
2469	struct zoran *zr = fh->zr;
2470	int res;
2471
2472	mutex_lock(&zr->resource_lock);
2473	res = zoran_set_input(zr, input);
2474	if (res)
2475		goto sinput_unlock_and_return;
2476
2477	/* Make sure the changes come into effect */
2478	res = wait_grab_pending(zr);
2479sinput_unlock_and_return:
2480	mutex_unlock(&zr->resource_lock);
2481	return res;
2482}
2483
2484static int zoran_enum_output(struct file *file, void *__fh,
2485				  struct v4l2_output *outp)
2486{
2487	if (outp->index != 0)
2488		return -EINVAL;
2489
2490	outp->index = 0;
2491	outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY;
2492	strncpy(outp->name, "Autodetect", sizeof(outp->name)-1);
2493
2494	return 0;
2495}
2496
2497static int zoran_g_output(struct file *file, void *__fh, unsigned int *output)
2498{
2499	*output = 0;
2500
2501	return 0;
2502}
2503
2504static int zoran_s_output(struct file *file, void *__fh, unsigned int output)
2505{
2506	if (output != 0)
2507		return -EINVAL;
2508
2509	return 0;
2510}
2511
2512/* cropping (sub-frame capture) */
2513static int zoran_cropcap(struct file *file, void *__fh,
2514					struct v4l2_cropcap *cropcap)
2515{
2516	struct zoran_fh *fh = __fh;
2517	struct zoran *zr = fh->zr;
2518	int type = cropcap->type, res = 0;
2519
2520	memset(cropcap, 0, sizeof(*cropcap));
2521	cropcap->type = type;
2522
2523	mutex_lock(&zr->resource_lock);
2524
2525	if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2526	    (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2527	     fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2528		dprintk(1, KERN_ERR
2529			"%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",
2530			ZR_DEVNAME(zr));
2531		res = -EINVAL;
2532		goto cropcap_unlock_and_return;
2533	}
2534
2535	cropcap->bounds.top = cropcap->bounds.left = 0;
2536	cropcap->bounds.width = BUZ_MAX_WIDTH;
2537	cropcap->bounds.height = BUZ_MAX_HEIGHT;
2538	cropcap->defrect.top = cropcap->defrect.left = 0;
2539	cropcap->defrect.width = BUZ_MIN_WIDTH;
2540	cropcap->defrect.height = BUZ_MIN_HEIGHT;
2541cropcap_unlock_and_return:
2542	mutex_unlock(&zr->resource_lock);
2543	return res;
2544}
2545
2546static int zoran_g_crop(struct file *file, void *__fh, struct v4l2_crop *crop)
2547{
2548	struct zoran_fh *fh = __fh;
2549	struct zoran *zr = fh->zr;
2550	int type = crop->type, res = 0;
2551
2552	memset(crop, 0, sizeof(*crop));
2553	crop->type = type;
2554
2555	mutex_lock(&zr->resource_lock);
2556
2557	if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2558	    (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2559	     fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2560		dprintk(1,
2561			KERN_ERR
2562			"%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2563			ZR_DEVNAME(zr));
2564		res = -EINVAL;
2565		goto gcrop_unlock_and_return;
2566	}
2567
2568	crop->c.top = fh->jpg_settings.img_y;
2569	crop->c.left = fh->jpg_settings.img_x;
2570	crop->c.width = fh->jpg_settings.img_width;
2571	crop->c.height = fh->jpg_settings.img_height;
2572
2573gcrop_unlock_and_return:
2574	mutex_unlock(&zr->resource_lock);
2575
2576	return res;
2577}
2578
2579static int zoran_s_crop(struct file *file, void *__fh, const struct v4l2_crop *crop)
2580{
2581	struct zoran_fh *fh = __fh;
2582	struct zoran *zr = fh->zr;
2583	int res = 0;
2584	struct zoran_jpg_settings settings;
2585
2586	settings = fh->jpg_settings;
2587
2588	mutex_lock(&zr->resource_lock);
2589
2590	if (fh->buffers.allocated) {
2591		dprintk(1, KERN_ERR
2592			"%s: VIDIOC_S_CROP - cannot change settings while active\n",
2593			ZR_DEVNAME(zr));
2594		res = -EBUSY;
2595		goto scrop_unlock_and_return;
2596	}
2597
2598	if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2599	    (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2600	     fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2601		dprintk(1, KERN_ERR
2602			"%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2603			ZR_DEVNAME(zr));
2604		res = -EINVAL;
2605		goto scrop_unlock_and_return;
2606	}
2607
2608	/* move into a form that we understand */
2609	settings.img_x = crop->c.left;
2610	settings.img_y = crop->c.top;
2611	settings.img_width = crop->c.width;
2612	settings.img_height = crop->c.height;
2613
2614	/* check validity */
2615	res = zoran_check_jpg_settings(zr, &settings, 0);
2616	if (res)
2617		goto scrop_unlock_and_return;
2618
2619	/* accept */
2620	fh->jpg_settings = settings;
2621
2622scrop_unlock_and_return:
2623	mutex_unlock(&zr->resource_lock);
2624	return res;
2625}
2626
2627static int zoran_g_jpegcomp(struct file *file, void *__fh,
2628					struct v4l2_jpegcompression *params)
2629{
2630	struct zoran_fh *fh = __fh;
2631	struct zoran *zr = fh->zr;
2632	memset(params, 0, sizeof(*params));
2633
2634	mutex_lock(&zr->resource_lock);
2635
2636	params->quality = fh->jpg_settings.jpg_comp.quality;
2637	params->APPn = fh->jpg_settings.jpg_comp.APPn;
2638	memcpy(params->APP_data,
2639	       fh->jpg_settings.jpg_comp.APP_data,
2640	       fh->jpg_settings.jpg_comp.APP_len);
2641	params->APP_len = fh->jpg_settings.jpg_comp.APP_len;
2642	memcpy(params->COM_data,
2643	       fh->jpg_settings.jpg_comp.COM_data,
2644	       fh->jpg_settings.jpg_comp.COM_len);
2645	params->COM_len = fh->jpg_settings.jpg_comp.COM_len;
2646	params->jpeg_markers =
2647	    fh->jpg_settings.jpg_comp.jpeg_markers;
2648
2649	mutex_unlock(&zr->resource_lock);
2650
2651	return 0;
2652}
2653
2654static int zoran_s_jpegcomp(struct file *file, void *__fh,
2655					const struct v4l2_jpegcompression *params)
2656{
2657	struct zoran_fh *fh = __fh;
2658	struct zoran *zr = fh->zr;
2659	int res = 0;
2660	struct zoran_jpg_settings settings;
2661
2662	settings = fh->jpg_settings;
2663
2664	settings.jpg_comp = *params;
2665
2666	mutex_lock(&zr->resource_lock);
2667
2668	if (fh->buffers.active != ZORAN_FREE) {
2669		dprintk(1, KERN_WARNING
2670			"%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
2671			ZR_DEVNAME(zr));
2672		res = -EBUSY;
2673		goto sjpegc_unlock_and_return;
2674	}
2675
2676	res = zoran_check_jpg_settings(zr, &settings, 0);
2677	if (res)
2678		goto sjpegc_unlock_and_return;
2679	if (!fh->buffers.allocated)
2680		fh->buffers.buffer_size =
2681			zoran_v4l2_calc_bufsize(&fh->jpg_settings);
2682	fh->jpg_settings.jpg_comp = settings.jpg_comp;
2683sjpegc_unlock_and_return:
2684	mutex_unlock(&zr->resource_lock);
2685
2686	return res;
2687}
2688
2689static unsigned int
2690zoran_poll (struct file *file,
2691	    poll_table  *wait)
2692{
2693	struct zoran_fh *fh = file->private_data;
2694	struct zoran *zr = fh->zr;
2695	int res = 0, frame;
2696	unsigned long flags;
2697
2698	/* we should check whether buffers are ready to be synced on
2699	 * (w/o waits - O_NONBLOCK) here
2700	 * if ready for read (sync), return POLLIN|POLLRDNORM,
2701	 * if ready for write (sync), return POLLOUT|POLLWRNORM,
2702	 * if error, return POLLERR,
2703	 * if no buffers queued or so, return POLLNVAL
2704	 */
2705
2706	mutex_lock(&zr->resource_lock);
2707
2708	switch (fh->map_mode) {
2709	case ZORAN_MAP_MODE_RAW:
2710		poll_wait(file, &zr->v4l_capq, wait);
2711		frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
2712
2713		spin_lock_irqsave(&zr->spinlock, flags);
2714		dprintk(3,
2715			KERN_DEBUG
2716			"%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
2717			ZR_DEVNAME(zr), __func__,
2718			"FAL"[fh->buffers.active], zr->v4l_sync_tail,
2719			"UPMD"[zr->v4l_buffers.buffer[frame].state],
2720			zr->v4l_pend_tail, zr->v4l_pend_head);
2721		/* Process is the one capturing? */
2722		if (fh->buffers.active != ZORAN_FREE &&
2723		    /* Buffer ready to DQBUF? */
2724		    zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE)
2725			res = POLLIN | POLLRDNORM;
2726		spin_unlock_irqrestore(&zr->spinlock, flags);
2727
2728		break;
2729
2730	case ZORAN_MAP_MODE_JPG_REC:
2731	case ZORAN_MAP_MODE_JPG_PLAY:
2732		poll_wait(file, &zr->jpg_capq, wait);
2733		frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
2734
2735		spin_lock_irqsave(&zr->spinlock, flags);
2736		dprintk(3,
2737			KERN_DEBUG
2738			"%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
2739			ZR_DEVNAME(zr), __func__,
2740			"FAL"[fh->buffers.active], zr->jpg_que_tail,
2741			"UPMD"[zr->jpg_buffers.buffer[frame].state],
2742			zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head);
2743		if (fh->buffers.active != ZORAN_FREE &&
2744		    zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) {
2745			if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC)
2746				res = POLLIN | POLLRDNORM;
2747			else
2748				res = POLLOUT | POLLWRNORM;
2749		}
2750		spin_unlock_irqrestore(&zr->spinlock, flags);
2751
2752		break;
2753
2754	default:
2755		dprintk(1,
2756			KERN_ERR
2757			"%s: %s - internal error, unknown map_mode=%d\n",
2758			ZR_DEVNAME(zr), __func__, fh->map_mode);
2759		res = POLLNVAL;
2760	}
2761
2762	mutex_unlock(&zr->resource_lock);
2763
2764	return res;
2765}
2766
2767
2768/*
2769 * This maps the buffers to user space.
2770 *
2771 * Depending on the state of fh->map_mode
2772 * the V4L or the MJPEG buffers are mapped
2773 * per buffer or all together
2774 *
2775 * Note that we need to connect to some
2776 * unmap signal event to unmap the de-allocate
2777 * the buffer accordingly (zoran_vm_close())
2778 */
2779
2780static void
2781zoran_vm_open (struct vm_area_struct *vma)
2782{
2783	struct zoran_mapping *map = vma->vm_private_data;
2784	atomic_inc(&map->count);
2785}
2786
2787static void
2788zoran_vm_close (struct vm_area_struct *vma)
2789{
2790	struct zoran_mapping *map = vma->vm_private_data;
2791	struct zoran_fh *fh = map->fh;
2792	struct zoran *zr = fh->zr;
2793	int i;
2794
2795	if (!atomic_dec_and_mutex_lock(&map->count, &zr->resource_lock))
2796		return;
2797
2798	dprintk(3, KERN_INFO "%s: %s - munmap(%s)\n", ZR_DEVNAME(zr),
2799		__func__, mode_name(fh->map_mode));
2800
2801	for (i = 0; i < fh->buffers.num_buffers; i++) {
2802		if (fh->buffers.buffer[i].map == map)
2803			fh->buffers.buffer[i].map = NULL;
2804	}
2805	kfree(map);
2806
2807	/* Any buffers still mapped? */
2808	for (i = 0; i < fh->buffers.num_buffers; i++) {
2809		if (fh->buffers.buffer[i].map) {
2810			mutex_unlock(&zr->resource_lock);
2811			return;
2812		}
2813	}
2814
2815	dprintk(3, KERN_INFO "%s: %s - free %s buffers\n", ZR_DEVNAME(zr),
2816		__func__, mode_name(fh->map_mode));
2817
2818
2819	if (fh->map_mode == ZORAN_MAP_MODE_RAW) {
2820		if (fh->buffers.active != ZORAN_FREE) {
2821			unsigned long flags;
2822
2823			spin_lock_irqsave(&zr->spinlock, flags);
2824			zr36057_set_memgrab(zr, 0);
2825			zr->v4l_buffers.allocated = 0;
2826			zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE;
2827			spin_unlock_irqrestore(&zr->spinlock, flags);
2828		}
2829		v4l_fbuffer_free(fh);
2830	} else {
2831		if (fh->buffers.active != ZORAN_FREE) {
2832			jpg_qbuf(fh, -1, zr->codec_mode);
2833			zr->jpg_buffers.allocated = 0;
2834			zr->jpg_buffers.active = fh->buffers.active = ZORAN_FREE;
2835		}
2836		jpg_fbuffer_free(fh);
2837	}
2838
2839	mutex_unlock(&zr->resource_lock);
2840}
2841
2842static const struct vm_operations_struct zoran_vm_ops = {
2843	.open = zoran_vm_open,
2844	.close = zoran_vm_close,
2845};
2846
2847static int
2848zoran_mmap (struct file           *file,
2849	    struct vm_area_struct *vma)
2850{
2851	struct zoran_fh *fh = file->private_data;
2852	struct zoran *zr = fh->zr;
2853	unsigned long size = (vma->vm_end - vma->vm_start);
2854	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
2855	int i, j;
2856	unsigned long page, start = vma->vm_start, todo, pos, fraglen;
2857	int first, last;
2858	struct zoran_mapping *map;
2859	int res = 0;
2860
2861	dprintk(3,
2862		KERN_INFO "%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
2863		ZR_DEVNAME(zr), __func__,
2864		mode_name(fh->map_mode), vma->vm_start, vma->vm_end, size);
2865
2866	if (!(vma->vm_flags & VM_SHARED) || !(vma->vm_flags & VM_READ) ||
2867	    !(vma->vm_flags & VM_WRITE)) {
2868		dprintk(1,
2869			KERN_ERR
2870			"%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n",
2871			ZR_DEVNAME(zr), __func__);
2872		return -EINVAL;
2873	}
2874
2875	mutex_lock(&zr->resource_lock);
2876
2877	if (!fh->buffers.allocated) {
2878		dprintk(1,
2879			KERN_ERR
2880			"%s: %s(%s) - buffers not yet allocated\n",
2881			ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode));
2882		res = -ENOMEM;
2883		goto mmap_unlock_and_return;
2884	}
2885
2886	first = offset / fh->buffers.buffer_size;
2887	last = first - 1 + size / fh->buffers.buffer_size;
2888	if (offset % fh->buffers.buffer_size != 0 ||
2889	    size % fh->buffers.buffer_size != 0 || first < 0 ||
2890	    last < 0 || first >= fh->buffers.num_buffers ||
2891	    last >= fh->buffers.buffer_size) {
2892		dprintk(1,
2893			KERN_ERR
2894			"%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
2895			ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), offset, size,
2896			fh->buffers.buffer_size,
2897			fh->buffers.num_buffers);
2898		res = -EINVAL;
2899		goto mmap_unlock_and_return;
2900	}
2901
2902	/* Check if any buffers are already mapped */
2903	for (i = first; i <= last; i++) {
2904		if (fh->buffers.buffer[i].map) {
2905			dprintk(1,
2906				KERN_ERR
2907				"%s: %s(%s) - buffer %d already mapped\n",
2908				ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), i);
2909			res = -EBUSY;
2910			goto mmap_unlock_and_return;
2911		}
2912	}
2913
2914	/* map these buffers */
2915	map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);
2916	if (!map) {
2917		res = -ENOMEM;
2918		goto mmap_unlock_and_return;
2919	}
2920	map->fh = fh;
2921	atomic_set(&map->count, 1);
2922
2923	vma->vm_ops = &zoran_vm_ops;
2924	vma->vm_flags |= VM_DONTEXPAND;
2925	vma->vm_private_data = map;
2926
2927	if (fh->map_mode == ZORAN_MAP_MODE_RAW) {
2928		for (i = first; i <= last; i++) {
2929			todo = size;
2930			if (todo > fh->buffers.buffer_size)
2931				todo = fh->buffers.buffer_size;
2932			page = fh->buffers.buffer[i].v4l.fbuffer_phys;
2933			if (remap_pfn_range(vma, start, page >> PAGE_SHIFT,
2934							todo, PAGE_SHARED)) {
2935				dprintk(1,
2936					KERN_ERR
2937					"%s: %s(V4L) - remap_pfn_range failed\n",
2938					ZR_DEVNAME(zr), __func__);
2939				res = -EAGAIN;
2940				goto mmap_unlock_and_return;
2941			}
2942			size -= todo;
2943			start += todo;
2944			fh->buffers.buffer[i].map = map;
2945			if (size == 0)
2946				break;
2947		}
2948	} else {
2949		for (i = first; i <= last; i++) {
2950			for (j = 0;
2951			     j < fh->buffers.buffer_size / PAGE_SIZE;
2952			     j++) {
2953				fraglen =
2954				    (le32_to_cpu(fh->buffers.buffer[i].jpg.
2955				     frag_tab[2 * j + 1]) & ~1) << 1;
2956				todo = size;
2957				if (todo > fraglen)
2958					todo = fraglen;
2959				pos =
2960				    le32_to_cpu(fh->buffers.
2961				    buffer[i].jpg.frag_tab[2 * j]);
2962				/* should just be pos on i386 */
2963				page = virt_to_phys(bus_to_virt(pos))
2964								>> PAGE_SHIFT;
2965				if (remap_pfn_range(vma, start, page,
2966							todo, PAGE_SHARED)) {
2967					dprintk(1,
2968						KERN_ERR
2969						"%s: %s(V4L) - remap_pfn_range failed\n",
2970						ZR_DEVNAME(zr), __func__);
2971					res = -EAGAIN;
2972					goto mmap_unlock_and_return;
2973				}
2974				size -= todo;
2975				start += todo;
2976				if (size == 0)
2977					break;
2978				if (le32_to_cpu(fh->buffers.buffer[i].jpg.
2979				    frag_tab[2 * j + 1]) & 1)
2980					break;	/* was last fragment */
2981			}
2982			fh->buffers.buffer[i].map = map;
2983			if (size == 0)
2984				break;
2985
2986		}
2987	}
2988
2989mmap_unlock_and_return:
2990	mutex_unlock(&zr->resource_lock);
2991
2992	return res;
2993}
2994
2995static const struct v4l2_ioctl_ops zoran_ioctl_ops = {
2996	.vidioc_querycap    		    = zoran_querycap,
2997	.vidioc_cropcap       		    = zoran_cropcap,
2998	.vidioc_s_crop       		    = zoran_s_crop,
2999	.vidioc_g_crop       		    = zoran_g_crop,
3000	.vidioc_enum_input     		    = zoran_enum_input,
3001	.vidioc_g_input      		    = zoran_g_input,
3002	.vidioc_s_input      		    = zoran_s_input,
3003	.vidioc_enum_output    		    = zoran_enum_output,
3004	.vidioc_g_output     		    = zoran_g_output,
3005	.vidioc_s_output     		    = zoran_s_output,
3006	.vidioc_g_fbuf			    = zoran_g_fbuf,
3007	.vidioc_s_fbuf			    = zoran_s_fbuf,
3008	.vidioc_g_std 			    = zoran_g_std,
3009	.vidioc_s_std 			    = zoran_s_std,
3010	.vidioc_g_jpegcomp 		    = zoran_g_jpegcomp,
3011	.vidioc_s_jpegcomp 		    = zoran_s_jpegcomp,
3012	.vidioc_overlay			    = zoran_overlay,
3013	.vidioc_reqbufs			    = zoran_reqbufs,
3014	.vidioc_querybuf		    = zoran_querybuf,
3015	.vidioc_qbuf			    = zoran_qbuf,
3016	.vidioc_dqbuf			    = zoran_dqbuf,
3017	.vidioc_streamon		    = zoran_streamon,
3018	.vidioc_streamoff		    = zoran_streamoff,
3019	.vidioc_enum_fmt_vid_cap 	    = zoran_enum_fmt_vid_cap,
3020	.vidioc_enum_fmt_vid_out 	    = zoran_enum_fmt_vid_out,
3021	.vidioc_enum_fmt_vid_overlay 	    = zoran_enum_fmt_vid_overlay,
3022	.vidioc_g_fmt_vid_cap 		    = zoran_g_fmt_vid_cap,
3023	.vidioc_g_fmt_vid_out               = zoran_g_fmt_vid_out,
3024	.vidioc_g_fmt_vid_overlay           = zoran_g_fmt_vid_overlay,
3025	.vidioc_s_fmt_vid_cap  		    = zoran_s_fmt_vid_cap,
3026	.vidioc_s_fmt_vid_out               = zoran_s_fmt_vid_out,
3027	.vidioc_s_fmt_vid_overlay           = zoran_s_fmt_vid_overlay,
3028	.vidioc_try_fmt_vid_cap  	    = zoran_try_fmt_vid_cap,
3029	.vidioc_try_fmt_vid_out 	    = zoran_try_fmt_vid_out,
3030	.vidioc_try_fmt_vid_overlay 	    = zoran_try_fmt_vid_overlay,
3031	.vidioc_queryctrl 		    = zoran_queryctrl,
3032	.vidioc_s_ctrl       		    = zoran_s_ctrl,
3033	.vidioc_g_ctrl       		    = zoran_g_ctrl,
3034};
3035
3036/* please use zr->resource_lock consistently and kill this wrapper */
3037static long zoran_ioctl(struct file *file, unsigned int cmd,
3038			unsigned long arg)
3039{
3040	struct zoran_fh *fh = file->private_data;
3041	struct zoran *zr = fh->zr;
3042	int ret;
3043
3044	mutex_lock(&zr->other_lock);
3045	ret = video_ioctl2(file, cmd, arg);
3046	mutex_unlock(&zr->other_lock);
3047
3048	return ret;
3049}
3050
3051static const struct v4l2_file_operations zoran_fops = {
3052	.owner = THIS_MODULE,
3053	.open = zoran_open,
3054	.release = zoran_close,
3055	.unlocked_ioctl = zoran_ioctl,
3056	.read = zoran_read,
3057	.write = zoran_write,
3058	.mmap = zoran_mmap,
3059	.poll = zoran_poll,
3060};
3061
3062struct video_device zoran_template = {
3063	.name = ZORAN_NAME,
3064	.fops = &zoran_fops,
3065	.ioctl_ops = &zoran_ioctl_ops,
3066	.release = &zoran_vdev_release,
3067	.tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
3068};
3069
3070