]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/media/video/zoran_driver.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use helpers to obtain task pid in printks
[mirror_ubuntu-focal-kernel.git] / drivers / media / video / zoran_driver.c
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/version.h>
48 #include <linux/init.h>
49 #include <linux/module.h>
50 #include <linux/delay.h>
51 #include <linux/slab.h>
52 #include <linux/pci.h>
53 #include <linux/vmalloc.h>
54 #include <linux/wait.h>
55 #include <linux/byteorder/generic.h>
56
57 #include <linux/interrupt.h>
58 #include <linux/i2c.h>
59 #include <linux/i2c-algo-bit.h>
60
61 #include <linux/spinlock.h>
62 #define MAP_NR(x) virt_to_page(x)
63 #define ZORAN_HARDWARE VID_HARDWARE_ZR36067
64 #define ZORAN_VID_TYPE ( \
65 VID_TYPE_CAPTURE | \
66 VID_TYPE_OVERLAY | \
67 VID_TYPE_CLIPPING | \
68 VID_TYPE_FRAMERAM | \
69 VID_TYPE_SCALES | \
70 VID_TYPE_MJPEG_DECODER | \
71 VID_TYPE_MJPEG_ENCODER \
72 )
73
74 #include <linux/videodev.h>
75 #include <media/v4l2-common.h>
76 #include "videocodec.h"
77
78 #include <asm/io.h>
79 #include <asm/uaccess.h>
80 #include <linux/proc_fs.h>
81
82 #include <linux/video_decoder.h>
83 #include <linux/video_encoder.h>
84 #include <linux/mutex.h>
85 #include "zoran.h"
86 #include "zoran_device.h"
87 #include "zoran_card.h"
88
89 #ifdef CONFIG_VIDEO_V4L2
90 /* we declare some card type definitions here, they mean
91 * the same as the v4l1 ZORAN_VID_TYPE above, except it's v4l2 */
92 #define ZORAN_V4L2_VID_FLAGS ( \
93 V4L2_CAP_STREAMING |\
94 V4L2_CAP_VIDEO_CAPTURE |\
95 V4L2_CAP_VIDEO_OUTPUT |\
96 V4L2_CAP_VIDEO_OVERLAY \
97 )
98 #endif
99
100 #include <asm/byteorder.h>
101
102 #if defined(CONFIG_VIDEO_V4L2) && defined(CONFIG_VIDEO_V4L1_COMPAT)
103 #define ZFMT(pal, fcc, cs) \
104 .palette = (pal), .fourcc = (fcc), .colorspace = (cs)
105 #elif defined(CONFIG_VIDEO_V4L2)
106 #define ZFMT(pal, fcc, cs) \
107 .fourcc = (fcc), .colorspace = (cs)
108 #else
109 #define ZFMT(pal, fcc, cs) \
110 .palette = (pal)
111 #endif
112
113 const struct zoran_format zoran_formats[] = {
114 {
115 .name = "15-bit RGB LE",
116 ZFMT(VIDEO_PALETTE_RGB555,
117 V4L2_PIX_FMT_RGB555, V4L2_COLORSPACE_SRGB),
118 .depth = 15,
119 .flags = ZORAN_FORMAT_CAPTURE |
120 ZORAN_FORMAT_OVERLAY,
121 .vfespfr = ZR36057_VFESPFR_RGB555|ZR36057_VFESPFR_ErrDif|
122 ZR36057_VFESPFR_LittleEndian,
123 }, {
124 .name = "15-bit RGB BE",
125 ZFMT(-1,
126 V4L2_PIX_FMT_RGB555X, V4L2_COLORSPACE_SRGB),
127 .depth = 15,
128 .flags = ZORAN_FORMAT_CAPTURE |
129 ZORAN_FORMAT_OVERLAY,
130 .vfespfr = ZR36057_VFESPFR_RGB555|ZR36057_VFESPFR_ErrDif,
131 }, {
132 .name = "16-bit RGB LE",
133 ZFMT(VIDEO_PALETTE_RGB565,
134 V4L2_PIX_FMT_RGB565, V4L2_COLORSPACE_SRGB),
135 .depth = 16,
136 .flags = ZORAN_FORMAT_CAPTURE |
137 ZORAN_FORMAT_OVERLAY,
138 .vfespfr = ZR36057_VFESPFR_RGB565|ZR36057_VFESPFR_ErrDif|
139 ZR36057_VFESPFR_LittleEndian,
140 }, {
141 .name = "16-bit RGB BE",
142 ZFMT(-1,
143 V4L2_PIX_FMT_RGB565, V4L2_COLORSPACE_SRGB),
144 .depth = 16,
145 .flags = ZORAN_FORMAT_CAPTURE |
146 ZORAN_FORMAT_OVERLAY,
147 .vfespfr = ZR36057_VFESPFR_RGB565|ZR36057_VFESPFR_ErrDif,
148 }, {
149 .name = "24-bit RGB",
150 ZFMT(VIDEO_PALETTE_RGB24,
151 V4L2_PIX_FMT_BGR24, V4L2_COLORSPACE_SRGB),
152 .depth = 24,
153 .flags = ZORAN_FORMAT_CAPTURE |
154 ZORAN_FORMAT_OVERLAY,
155 .vfespfr = ZR36057_VFESPFR_RGB888|ZR36057_VFESPFR_Pack24,
156 }, {
157 .name = "32-bit RGB LE",
158 ZFMT(VIDEO_PALETTE_RGB32,
159 V4L2_PIX_FMT_BGR32, V4L2_COLORSPACE_SRGB),
160 .depth = 32,
161 .flags = ZORAN_FORMAT_CAPTURE |
162 ZORAN_FORMAT_OVERLAY,
163 .vfespfr = ZR36057_VFESPFR_RGB888|ZR36057_VFESPFR_LittleEndian,
164 }, {
165 .name = "32-bit RGB BE",
166 ZFMT(-1,
167 V4L2_PIX_FMT_RGB32, V4L2_COLORSPACE_SRGB),
168 .depth = 32,
169 .flags = ZORAN_FORMAT_CAPTURE |
170 ZORAN_FORMAT_OVERLAY,
171 .vfespfr = ZR36057_VFESPFR_RGB888,
172 }, {
173 .name = "4:2:2, packed, YUYV",
174 ZFMT(VIDEO_PALETTE_YUV422,
175 V4L2_PIX_FMT_YUYV, V4L2_COLORSPACE_SMPTE170M),
176 .depth = 16,
177 .flags = ZORAN_FORMAT_CAPTURE |
178 ZORAN_FORMAT_OVERLAY,
179 .vfespfr = ZR36057_VFESPFR_YUV422,
180 }, {
181 .name = "4:2:2, packed, UYVY",
182 ZFMT(VIDEO_PALETTE_UYVY,
183 V4L2_PIX_FMT_UYVY, V4L2_COLORSPACE_SMPTE170M),
184 .depth = 16,
185 .flags = ZORAN_FORMAT_CAPTURE |
186 ZORAN_FORMAT_OVERLAY,
187 .vfespfr = ZR36057_VFESPFR_YUV422|ZR36057_VFESPFR_LittleEndian,
188 }, {
189 .name = "Hardware-encoded Motion-JPEG",
190 ZFMT(-1,
191 V4L2_PIX_FMT_MJPEG, V4L2_COLORSPACE_SMPTE170M),
192 .depth = 0,
193 .flags = ZORAN_FORMAT_CAPTURE |
194 ZORAN_FORMAT_PLAYBACK |
195 ZORAN_FORMAT_COMPRESSED,
196 }
197 };
198 #define NUM_FORMATS ARRAY_SIZE(zoran_formats)
199
200 // RJ: Test only - want to test BUZ_USE_HIMEM even when CONFIG_BIGPHYS_AREA is defined
201
202
203 extern int v4l_nbufs;
204 extern int v4l_bufsize;
205 extern int jpg_nbufs;
206 extern int jpg_bufsize;
207 extern int pass_through;
208
209 static int lock_norm = 0; /* 1=Don't change TV standard (norm) */
210 module_param(lock_norm, int, 0644);
211 MODULE_PARM_DESC(lock_norm, "Prevent norm changes (1 = ignore, >1 = fail)");
212
213 #ifdef CONFIG_VIDEO_V4L2
214 /* small helper function for calculating buffersizes for v4l2
215 * we calculate the nearest higher power-of-two, which
216 * will be the recommended buffersize */
217 static __u32
218 zoran_v4l2_calc_bufsize (struct zoran_jpg_settings *settings)
219 {
220 __u8 div = settings->VerDcm * settings->HorDcm * settings->TmpDcm;
221 __u32 num = (1024 * 512) / (div);
222 __u32 result = 2;
223
224 num--;
225 while (num) {
226 num >>= 1;
227 result <<= 1;
228 }
229
230 if (result > jpg_bufsize)
231 return jpg_bufsize;
232 if (result < 8192)
233 return 8192;
234 return result;
235 }
236 #endif
237
238 /* forward references */
239 static void v4l_fbuffer_free(struct file *file);
240 static void jpg_fbuffer_free(struct file *file);
241
242 /*
243 * Allocate the V4L grab buffers
244 *
245 * These have to be pysically contiguous.
246 * If v4l_bufsize <= MAX_KMALLOC_MEM we use kmalloc
247 * else we try to allocate them with bigphysarea_alloc_pages
248 * if the bigphysarea patch is present in the kernel,
249 * else we try to use high memory (if the user has bootet
250 * Linux with the necessary memory left over).
251 */
252
253 static unsigned long
254 get_high_mem (unsigned long size)
255 {
256 /*
257 * Check if there is usable memory at the end of Linux memory
258 * of at least size. Return the physical address of this memory,
259 * return 0 on failure.
260 *
261 * The idea is from Alexandro Rubini's book "Linux device drivers".
262 * The driver from him which is downloadable from O'Reilly's
263 * web site misses the "virt_to_phys(high_memory)" part
264 * (and therefore doesn't work at all - at least with 2.2.x kernels).
265 *
266 * It should be unnecessary to mention that THIS IS DANGEROUS,
267 * if more than one driver at a time has the idea to use this memory!!!!
268 */
269
270 volatile unsigned char __iomem *mem;
271 unsigned char c;
272 unsigned long hi_mem_ph;
273 unsigned long i;
274
275 /* Map the high memory to user space */
276
277 hi_mem_ph = virt_to_phys(high_memory);
278
279 mem = ioremap(hi_mem_ph, size);
280 if (!mem) {
281 dprintk(1,
282 KERN_ERR "%s: get_high_mem() - ioremap failed\n",
283 ZORAN_NAME);
284 return 0;
285 }
286
287 for (i = 0; i < size; i++) {
288 /* Check if it is memory */
289 c = i & 0xff;
290 writeb(c, mem + i);
291 if (readb(mem + i) != c)
292 break;
293 c = 255 - c;
294 writeb(c, mem + i);
295 if (readb(mem + i) != c)
296 break;
297 writeb(0, mem + i); /* zero out memory */
298
299 /* give the kernel air to breath */
300 if ((i & 0x3ffff) == 0x3ffff)
301 schedule();
302 }
303
304 iounmap(mem);
305
306 if (i != size) {
307 dprintk(1,
308 KERN_ERR
309 "%s: get_high_mem() - requested %lu, avail %lu\n",
310 ZORAN_NAME, size, i);
311 return 0;
312 }
313
314 return hi_mem_ph;
315 }
316
317 static int
318 v4l_fbuffer_alloc (struct file *file)
319 {
320 struct zoran_fh *fh = file->private_data;
321 struct zoran *zr = fh->zr;
322 int i, off;
323 unsigned char *mem;
324 unsigned long pmem = 0;
325
326 /* we might have old buffers lying around... */
327 if (fh->v4l_buffers.ready_to_be_freed) {
328 v4l_fbuffer_free(file);
329 }
330
331 for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {
332 if (fh->v4l_buffers.buffer[i].fbuffer)
333 dprintk(2,
334 KERN_WARNING
335 "%s: v4l_fbuffer_alloc() - buffer %d allready allocated!?\n",
336 ZR_DEVNAME(zr), i);
337
338 //udelay(20);
339 if (fh->v4l_buffers.buffer_size <= MAX_KMALLOC_MEM) {
340 /* Use kmalloc */
341
342 mem = kmalloc(fh->v4l_buffers.buffer_size, GFP_KERNEL);
343 if (mem == 0) {
344 dprintk(1,
345 KERN_ERR
346 "%s: v4l_fbuffer_alloc() - kmalloc for V4L buf %d failed\n",
347 ZR_DEVNAME(zr), i);
348 v4l_fbuffer_free(file);
349 return -ENOBUFS;
350 }
351 fh->v4l_buffers.buffer[i].fbuffer = mem;
352 fh->v4l_buffers.buffer[i].fbuffer_phys =
353 virt_to_phys(mem);
354 fh->v4l_buffers.buffer[i].fbuffer_bus =
355 virt_to_bus(mem);
356 for (off = 0; off < fh->v4l_buffers.buffer_size;
357 off += PAGE_SIZE)
358 SetPageReserved(MAP_NR(mem + off));
359 dprintk(4,
360 KERN_INFO
361 "%s: v4l_fbuffer_alloc() - V4L frame %d mem 0x%lx (bus: 0x%lx)\n",
362 ZR_DEVNAME(zr), i, (unsigned long) mem,
363 virt_to_bus(mem));
364 } else {
365
366 /* Use high memory which has been left at boot time */
367
368 /* Ok., Ok. this is an evil hack - we make
369 * the assumption that physical addresses are
370 * the same as bus addresses (true at least
371 * for Intel processors). The whole method of
372 * obtaining and using this memory is not very
373 * nice - but I hope it saves some poor users
374 * from kernel hacking, which might have even
375 * more evil results */
376
377 if (i == 0) {
378 int size =
379 fh->v4l_buffers.num_buffers *
380 fh->v4l_buffers.buffer_size;
381
382 pmem = get_high_mem(size);
383 if (pmem == 0) {
384 dprintk(1,
385 KERN_ERR
386 "%s: v4l_fbuffer_alloc() - get_high_mem (size = %d KB) for V4L bufs failed\n",
387 ZR_DEVNAME(zr), size >> 10);
388 return -ENOBUFS;
389 }
390 fh->v4l_buffers.buffer[0].fbuffer = NULL;
391 fh->v4l_buffers.buffer[0].fbuffer_phys = pmem;
392 fh->v4l_buffers.buffer[0].fbuffer_bus = pmem;
393 dprintk(4,
394 KERN_INFO
395 "%s: v4l_fbuffer_alloc() - using %d KB high memory\n",
396 ZR_DEVNAME(zr), size >> 10);
397 } else {
398 fh->v4l_buffers.buffer[i].fbuffer = NULL;
399 fh->v4l_buffers.buffer[i].fbuffer_phys =
400 pmem + i * fh->v4l_buffers.buffer_size;
401 fh->v4l_buffers.buffer[i].fbuffer_bus =
402 pmem + i * fh->v4l_buffers.buffer_size;
403 }
404 }
405 }
406
407 fh->v4l_buffers.allocated = 1;
408
409 return 0;
410 }
411
412 /* free the V4L grab buffers */
413 static void
414 v4l_fbuffer_free (struct file *file)
415 {
416 struct zoran_fh *fh = file->private_data;
417 struct zoran *zr = fh->zr;
418 int i, off;
419 unsigned char *mem;
420
421 dprintk(4, KERN_INFO "%s: v4l_fbuffer_free()\n", ZR_DEVNAME(zr));
422
423 for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {
424 if (!fh->v4l_buffers.buffer[i].fbuffer)
425 continue;
426
427 if (fh->v4l_buffers.buffer_size <= MAX_KMALLOC_MEM) {
428 mem = fh->v4l_buffers.buffer[i].fbuffer;
429 for (off = 0; off < fh->v4l_buffers.buffer_size;
430 off += PAGE_SIZE)
431 ClearPageReserved(MAP_NR(mem + off));
432 kfree((void *) fh->v4l_buffers.buffer[i].fbuffer);
433 }
434 fh->v4l_buffers.buffer[i].fbuffer = NULL;
435 }
436
437 fh->v4l_buffers.allocated = 0;
438 fh->v4l_buffers.ready_to_be_freed = 0;
439 }
440
441 /*
442 * Allocate the MJPEG grab buffers.
443 *
444 * If the requested buffer size is smaller than MAX_KMALLOC_MEM,
445 * kmalloc is used to request a physically contiguous area,
446 * else we allocate the memory in framgents with get_zeroed_page.
447 *
448 * If a Natoma chipset is present and this is a revision 1 zr36057,
449 * each MJPEG buffer needs to be physically contiguous.
450 * (RJ: This statement is from Dave Perks' original driver,
451 * I could never check it because I have a zr36067)
452 * The driver cares about this because it reduces the buffer
453 * size to MAX_KMALLOC_MEM in that case (which forces contiguous allocation).
454 *
455 * RJ: The contents grab buffers needs never be accessed in the driver.
456 * Therefore there is no need to allocate them with vmalloc in order
457 * to get a contiguous virtual memory space.
458 * I don't understand why many other drivers first allocate them with
459 * vmalloc (which uses internally also get_zeroed_page, but delivers you
460 * virtual addresses) and then again have to make a lot of efforts
461 * to get the physical address.
462 *
463 * Ben Capper:
464 * On big-endian architectures (such as ppc) some extra steps
465 * are needed. When reading and writing to the stat_com array
466 * and fragment buffers, the device expects to see little-
467 * endian values. The use of cpu_to_le32() and le32_to_cpu()
468 * in this function (and one or two others in zoran_device.c)
469 * ensure that these values are always stored in little-endian
470 * form, regardless of architecture. The zr36057 does Very Bad
471 * Things on big endian architectures if the stat_com array
472 * and fragment buffers are not little-endian.
473 */
474
475 static int
476 jpg_fbuffer_alloc (struct file *file)
477 {
478 struct zoran_fh *fh = file->private_data;
479 struct zoran *zr = fh->zr;
480 int i, j, off;
481 unsigned long mem;
482
483 /* we might have old buffers lying around */
484 if (fh->jpg_buffers.ready_to_be_freed) {
485 jpg_fbuffer_free(file);
486 }
487
488 for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {
489 if (fh->jpg_buffers.buffer[i].frag_tab)
490 dprintk(2,
491 KERN_WARNING
492 "%s: jpg_fbuffer_alloc() - buffer %d allready allocated!?\n",
493 ZR_DEVNAME(zr), i);
494
495 /* Allocate fragment table for this buffer */
496
497 mem = get_zeroed_page(GFP_KERNEL);
498 if (mem == 0) {
499 dprintk(1,
500 KERN_ERR
501 "%s: jpg_fbuffer_alloc() - get_zeroed_page (frag_tab) failed for buffer %d\n",
502 ZR_DEVNAME(zr), i);
503 jpg_fbuffer_free(file);
504 return -ENOBUFS;
505 }
506 fh->jpg_buffers.buffer[i].frag_tab = (u32 *) mem;
507 fh->jpg_buffers.buffer[i].frag_tab_bus =
508 virt_to_bus((void *) mem);
509
510 //if (alloc_contig) {
511 if (fh->jpg_buffers.need_contiguous) {
512 mem =
513 (unsigned long) kmalloc(fh->jpg_buffers.
514 buffer_size,
515 GFP_KERNEL);
516 if (mem == 0) {
517 dprintk(1,
518 KERN_ERR
519 "%s: jpg_fbuffer_alloc() - kmalloc failed for buffer %d\n",
520 ZR_DEVNAME(zr), i);
521 jpg_fbuffer_free(file);
522 return -ENOBUFS;
523 }
524 fh->jpg_buffers.buffer[i].frag_tab[0] =
525 cpu_to_le32(virt_to_bus((void *) mem));
526 fh->jpg_buffers.buffer[i].frag_tab[1] =
527 cpu_to_le32(((fh->jpg_buffers.buffer_size / 4) << 1) | 1);
528 for (off = 0; off < fh->jpg_buffers.buffer_size;
529 off += PAGE_SIZE)
530 SetPageReserved(MAP_NR(mem + off));
531 } else {
532 /* jpg_bufsize is allreay page aligned */
533 for (j = 0;
534 j < fh->jpg_buffers.buffer_size / PAGE_SIZE;
535 j++) {
536 mem = get_zeroed_page(GFP_KERNEL);
537 if (mem == 0) {
538 dprintk(1,
539 KERN_ERR
540 "%s: jpg_fbuffer_alloc() - get_zeroed_page failed for buffer %d\n",
541 ZR_DEVNAME(zr), i);
542 jpg_fbuffer_free(file);
543 return -ENOBUFS;
544 }
545
546 fh->jpg_buffers.buffer[i].frag_tab[2 * j] =
547 cpu_to_le32(virt_to_bus((void *) mem));
548 fh->jpg_buffers.buffer[i].frag_tab[2 * j +
549 1] =
550 cpu_to_le32((PAGE_SIZE / 4) << 1);
551 SetPageReserved(MAP_NR(mem));
552 }
553
554 fh->jpg_buffers.buffer[i].frag_tab[2 * j - 1] |= cpu_to_le32(1);
555 }
556 }
557
558 dprintk(4,
559 KERN_DEBUG "%s: jpg_fbuffer_alloc() - %d KB allocated\n",
560 ZR_DEVNAME(zr),
561 (fh->jpg_buffers.num_buffers *
562 fh->jpg_buffers.buffer_size) >> 10);
563
564 fh->jpg_buffers.allocated = 1;
565
566 return 0;
567 }
568
569 /* free the MJPEG grab buffers */
570 static void
571 jpg_fbuffer_free (struct file *file)
572 {
573 struct zoran_fh *fh = file->private_data;
574 struct zoran *zr = fh->zr;
575 int i, j, off;
576 unsigned char *mem;
577
578 dprintk(4, KERN_DEBUG "%s: jpg_fbuffer_free()\n", ZR_DEVNAME(zr));
579
580 for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {
581 if (!fh->jpg_buffers.buffer[i].frag_tab)
582 continue;
583
584 //if (alloc_contig) {
585 if (fh->jpg_buffers.need_contiguous) {
586 if (fh->jpg_buffers.buffer[i].frag_tab[0]) {
587 mem = (unsigned char *) bus_to_virt(le32_to_cpu(
588 fh->jpg_buffers.buffer[i].frag_tab[0]));
589 for (off = 0;
590 off < fh->jpg_buffers.buffer_size;
591 off += PAGE_SIZE)
592 ClearPageReserved(MAP_NR
593 (mem + off));
594 kfree(mem);
595 fh->jpg_buffers.buffer[i].frag_tab[0] = 0;
596 fh->jpg_buffers.buffer[i].frag_tab[1] = 0;
597 }
598 } else {
599 for (j = 0;
600 j < fh->jpg_buffers.buffer_size / PAGE_SIZE;
601 j++) {
602 if (!fh->jpg_buffers.buffer[i].
603 frag_tab[2 * j])
604 break;
605 ClearPageReserved(MAP_NR
606 (bus_to_virt
607 (le32_to_cpu
608 (fh->jpg_buffers.
609 buffer[i].frag_tab[2 *
610 j]))));
611 free_page((unsigned long)
612 bus_to_virt
613 (le32_to_cpu
614 (fh->jpg_buffers.
615 buffer[i].
616 frag_tab[2 * j])));
617 fh->jpg_buffers.buffer[i].frag_tab[2 * j] =
618 0;
619 fh->jpg_buffers.buffer[i].frag_tab[2 * j +
620 1] = 0;
621 }
622 }
623
624 free_page((unsigned long) fh->jpg_buffers.buffer[i].
625 frag_tab);
626 fh->jpg_buffers.buffer[i].frag_tab = NULL;
627 }
628
629 fh->jpg_buffers.allocated = 0;
630 fh->jpg_buffers.ready_to_be_freed = 0;
631 }
632
633 /*
634 * V4L Buffer grabbing
635 */
636
637 static int
638 zoran_v4l_set_format (struct file *file,
639 int width,
640 int height,
641 const struct zoran_format *format)
642 {
643 struct zoran_fh *fh = file->private_data;
644 struct zoran *zr = fh->zr;
645 int bpp;
646
647 /* Check size and format of the grab wanted */
648
649 if (height < BUZ_MIN_HEIGHT || width < BUZ_MIN_WIDTH ||
650 height > BUZ_MAX_HEIGHT || width > BUZ_MAX_WIDTH) {
651 dprintk(1,
652 KERN_ERR
653 "%s: v4l_set_format() - wrong frame size (%dx%d)\n",
654 ZR_DEVNAME(zr), width, height);
655 return -EINVAL;
656 }
657
658 bpp = (format->depth + 7) / 8;
659
660 /* Check against available buffer size */
661 if (height * width * bpp > fh->v4l_buffers.buffer_size) {
662 dprintk(1,
663 KERN_ERR
664 "%s: v4l_set_format() - video buffer size (%d kB) is too small\n",
665 ZR_DEVNAME(zr), fh->v4l_buffers.buffer_size >> 10);
666 return -EINVAL;
667 }
668
669 /* The video front end needs 4-byte alinged line sizes */
670
671 if ((bpp == 2 && (width & 1)) || (bpp == 3 && (width & 3))) {
672 dprintk(1,
673 KERN_ERR
674 "%s: v4l_set_format() - wrong frame alingment\n",
675 ZR_DEVNAME(zr));
676 return -EINVAL;
677 }
678
679 fh->v4l_settings.width = width;
680 fh->v4l_settings.height = height;
681 fh->v4l_settings.format = format;
682 fh->v4l_settings.bytesperline = bpp * fh->v4l_settings.width;
683
684 return 0;
685 }
686
687 static int
688 zoran_v4l_queue_frame (struct file *file,
689 int num)
690 {
691 struct zoran_fh *fh = file->private_data;
692 struct zoran *zr = fh->zr;
693 unsigned long flags;
694 int res = 0;
695
696 if (!fh->v4l_buffers.allocated) {
697 dprintk(1,
698 KERN_ERR
699 "%s: v4l_queue_frame() - buffers not yet allocated\n",
700 ZR_DEVNAME(zr));
701 res = -ENOMEM;
702 }
703
704 /* No grabbing outside the buffer range! */
705 if (num >= fh->v4l_buffers.num_buffers || num < 0) {
706 dprintk(1,
707 KERN_ERR
708 "%s: v4l_queue_frame() - buffer %d is out of range\n",
709 ZR_DEVNAME(zr), num);
710 res = -EINVAL;
711 }
712
713 spin_lock_irqsave(&zr->spinlock, flags);
714
715 if (fh->v4l_buffers.active == ZORAN_FREE) {
716 if (zr->v4l_buffers.active == ZORAN_FREE) {
717 zr->v4l_buffers = fh->v4l_buffers;
718 fh->v4l_buffers.active = ZORAN_ACTIVE;
719 } else {
720 dprintk(1,
721 KERN_ERR
722 "%s: v4l_queue_frame() - another session is already capturing\n",
723 ZR_DEVNAME(zr));
724 res = -EBUSY;
725 }
726 }
727
728 /* make sure a grab isn't going on currently with this buffer */
729 if (!res) {
730 switch (zr->v4l_buffers.buffer[num].state) {
731 default:
732 case BUZ_STATE_PEND:
733 if (zr->v4l_buffers.active == ZORAN_FREE) {
734 fh->v4l_buffers.active = ZORAN_FREE;
735 zr->v4l_buffers.allocated = 0;
736 }
737 res = -EBUSY; /* what are you doing? */
738 break;
739 case BUZ_STATE_DONE:
740 dprintk(2,
741 KERN_WARNING
742 "%s: v4l_queue_frame() - queueing buffer %d in state DONE!?\n",
743 ZR_DEVNAME(zr), num);
744 case BUZ_STATE_USER:
745 /* since there is at least one unused buffer there's room for at least
746 * one more pend[] entry */
747 zr->v4l_pend[zr->v4l_pend_head++ &
748 V4L_MASK_FRAME] = num;
749 zr->v4l_buffers.buffer[num].state = BUZ_STATE_PEND;
750 zr->v4l_buffers.buffer[num].bs.length =
751 fh->v4l_settings.bytesperline *
752 zr->v4l_settings.height;
753 fh->v4l_buffers.buffer[num] =
754 zr->v4l_buffers.buffer[num];
755 break;
756 }
757 }
758
759 spin_unlock_irqrestore(&zr->spinlock, flags);
760
761 if (!res && zr->v4l_buffers.active == ZORAN_FREE)
762 zr->v4l_buffers.active = fh->v4l_buffers.active;
763
764 return res;
765 }
766
767 static int
768 v4l_grab (struct file *file,
769 struct video_mmap *mp)
770 {
771 struct zoran_fh *fh = file->private_data;
772 struct zoran *zr = fh->zr;
773 int res = 0, i;
774
775 for (i = 0; i < NUM_FORMATS; i++) {
776 if (zoran_formats[i].palette == mp->format &&
777 zoran_formats[i].flags & ZORAN_FORMAT_CAPTURE &&
778 !(zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED))
779 break;
780 }
781 if (i == NUM_FORMATS || zoran_formats[i].depth == 0) {
782 dprintk(1,
783 KERN_ERR
784 "%s: v4l_grab() - wrong bytes-per-pixel format\n",
785 ZR_DEVNAME(zr));
786 return -EINVAL;
787 }
788
789 /*
790 * To minimize the time spent in the IRQ routine, we avoid setting up
791 * the video front end there.
792 * If this grab has different parameters from a running streaming capture
793 * we stop the streaming capture and start it over again.
794 */
795 if (zr->v4l_memgrab_active &&
796 (zr->v4l_settings.width != mp->width ||
797 zr->v4l_settings.height != mp->height ||
798 zr->v4l_settings.format->palette != mp->format)) {
799 res = wait_grab_pending(zr);
800 if (res)
801 return res;
802 }
803 if ((res = zoran_v4l_set_format(file,
804 mp->width,
805 mp->height,
806 &zoran_formats[i])))
807 return res;
808 zr->v4l_settings = fh->v4l_settings;
809
810 /* queue the frame in the pending queue */
811 if ((res = zoran_v4l_queue_frame(file, mp->frame))) {
812 fh->v4l_buffers.active = ZORAN_FREE;
813 return res;
814 }
815
816 /* put the 36057 into frame grabbing mode */
817 if (!res && !zr->v4l_memgrab_active)
818 zr36057_set_memgrab(zr, 1);
819
820 //dprintk(4, KERN_INFO "%s: Frame grab 3...\n", ZR_DEVNAME(zr));
821
822 return res;
823 }
824
825 /*
826 * Sync on a V4L buffer
827 */
828
829 static int
830 v4l_sync (struct file *file,
831 int frame)
832 {
833 struct zoran_fh *fh = file->private_data;
834 struct zoran *zr = fh->zr;
835 unsigned long flags;
836
837 if (fh->v4l_buffers.active == ZORAN_FREE) {
838 dprintk(1,
839 KERN_ERR
840 "%s: v4l_sync() - no grab active for this session\n",
841 ZR_DEVNAME(zr));
842 return -EINVAL;
843 }
844
845 /* check passed-in frame number */
846 if (frame >= fh->v4l_buffers.num_buffers || frame < 0) {
847 dprintk(1,
848 KERN_ERR "%s: v4l_sync() - frame %d is invalid\n",
849 ZR_DEVNAME(zr), frame);
850 return -EINVAL;
851 }
852
853 /* Check if is buffer was queued at all */
854 if (zr->v4l_buffers.buffer[frame].state == BUZ_STATE_USER) {
855 dprintk(1,
856 KERN_ERR
857 "%s: v4l_sync() - attempt to sync on a buffer which was not queued?\n",
858 ZR_DEVNAME(zr));
859 return -EPROTO;
860 }
861
862 /* wait on this buffer to get ready */
863 if (!wait_event_interruptible_timeout(zr->v4l_capq,
864 (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_PEND),
865 10*HZ))
866 return -ETIME;
867 if (signal_pending(current))
868 return -ERESTARTSYS;
869
870 /* buffer should now be in BUZ_STATE_DONE */
871 if (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_DONE)
872 dprintk(2,
873 KERN_ERR "%s: v4l_sync() - internal state error\n",
874 ZR_DEVNAME(zr));
875
876 zr->v4l_buffers.buffer[frame].state = BUZ_STATE_USER;
877 fh->v4l_buffers.buffer[frame] = zr->v4l_buffers.buffer[frame];
878
879 spin_lock_irqsave(&zr->spinlock, flags);
880
881 /* Check if streaming capture has finished */
882 if (zr->v4l_pend_tail == zr->v4l_pend_head) {
883 zr36057_set_memgrab(zr, 0);
884 if (zr->v4l_buffers.active == ZORAN_ACTIVE) {
885 fh->v4l_buffers.active = zr->v4l_buffers.active =
886 ZORAN_FREE;
887 zr->v4l_buffers.allocated = 0;
888 }
889 }
890
891 spin_unlock_irqrestore(&zr->spinlock, flags);
892
893 return 0;
894 }
895
896 /*
897 * Queue a MJPEG buffer for capture/playback
898 */
899
900 static int
901 zoran_jpg_queue_frame (struct file *file,
902 int num,
903 enum zoran_codec_mode mode)
904 {
905 struct zoran_fh *fh = file->private_data;
906 struct zoran *zr = fh->zr;
907 unsigned long flags;
908 int res = 0;
909
910 /* Check if buffers are allocated */
911 if (!fh->jpg_buffers.allocated) {
912 dprintk(1,
913 KERN_ERR
914 "%s: jpg_queue_frame() - buffers not yet allocated\n",
915 ZR_DEVNAME(zr));
916 return -ENOMEM;
917 }
918
919 /* No grabbing outside the buffer range! */
920 if (num >= fh->jpg_buffers.num_buffers || num < 0) {
921 dprintk(1,
922 KERN_ERR
923 "%s: jpg_queue_frame() - buffer %d out of range\n",
924 ZR_DEVNAME(zr), num);
925 return -EINVAL;
926 }
927
928 /* what is the codec mode right now? */
929 if (zr->codec_mode == BUZ_MODE_IDLE) {
930 zr->jpg_settings = fh->jpg_settings;
931 } else if (zr->codec_mode != mode) {
932 /* wrong codec mode active - invalid */
933 dprintk(1,
934 KERN_ERR
935 "%s: jpg_queue_frame() - codec in wrong mode\n",
936 ZR_DEVNAME(zr));
937 return -EINVAL;
938 }
939
940 if (fh->jpg_buffers.active == ZORAN_FREE) {
941 if (zr->jpg_buffers.active == ZORAN_FREE) {
942 zr->jpg_buffers = fh->jpg_buffers;
943 fh->jpg_buffers.active = ZORAN_ACTIVE;
944 } else {
945 dprintk(1,
946 KERN_ERR
947 "%s: jpg_queue_frame() - another session is already capturing\n",
948 ZR_DEVNAME(zr));
949 res = -EBUSY;
950 }
951 }
952
953 if (!res && zr->codec_mode == BUZ_MODE_IDLE) {
954 /* Ok load up the jpeg codec */
955 zr36057_enable_jpg(zr, mode);
956 }
957
958 spin_lock_irqsave(&zr->spinlock, flags);
959
960 if (!res) {
961 switch (zr->jpg_buffers.buffer[num].state) {
962 case BUZ_STATE_DONE:
963 dprintk(2,
964 KERN_WARNING
965 "%s: jpg_queue_frame() - queing frame in BUZ_STATE_DONE state!?\n",
966 ZR_DEVNAME(zr));
967 case BUZ_STATE_USER:
968 /* since there is at least one unused buffer there's room for at
969 *least one more pend[] entry */
970 zr->jpg_pend[zr->jpg_que_head++ & BUZ_MASK_FRAME] =
971 num;
972 zr->jpg_buffers.buffer[num].state = BUZ_STATE_PEND;
973 fh->jpg_buffers.buffer[num] =
974 zr->jpg_buffers.buffer[num];
975 zoran_feed_stat_com(zr);
976 break;
977 default:
978 case BUZ_STATE_DMA:
979 case BUZ_STATE_PEND:
980 if (zr->jpg_buffers.active == ZORAN_FREE) {
981 fh->jpg_buffers.active = ZORAN_FREE;
982 zr->jpg_buffers.allocated = 0;
983 }
984 res = -EBUSY; /* what are you doing? */
985 break;
986 }
987 }
988
989 spin_unlock_irqrestore(&zr->spinlock, flags);
990
991 if (!res && zr->jpg_buffers.active == ZORAN_FREE) {
992 zr->jpg_buffers.active = fh->jpg_buffers.active;
993 }
994
995 return res;
996 }
997
998 static int
999 jpg_qbuf (struct file *file,
1000 int frame,
1001 enum zoran_codec_mode mode)
1002 {
1003 struct zoran_fh *fh = file->private_data;
1004 struct zoran *zr = fh->zr;
1005 int res = 0;
1006
1007 /* Does the user want to stop streaming? */
1008 if (frame < 0) {
1009 if (zr->codec_mode == mode) {
1010 if (fh->jpg_buffers.active == ZORAN_FREE) {
1011 dprintk(1,
1012 KERN_ERR
1013 "%s: jpg_qbuf(-1) - session not active\n",
1014 ZR_DEVNAME(zr));
1015 return -EINVAL;
1016 }
1017 fh->jpg_buffers.active = zr->jpg_buffers.active =
1018 ZORAN_FREE;
1019 zr->jpg_buffers.allocated = 0;
1020 zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
1021 return 0;
1022 } else {
1023 dprintk(1,
1024 KERN_ERR
1025 "%s: jpg_qbuf() - stop streaming but not in streaming mode\n",
1026 ZR_DEVNAME(zr));
1027 return -EINVAL;
1028 }
1029 }
1030
1031 if ((res = zoran_jpg_queue_frame(file, frame, mode)))
1032 return res;
1033
1034 /* Start the jpeg codec when the first frame is queued */
1035 if (!res && zr->jpg_que_head == 1)
1036 jpeg_start(zr);
1037
1038 return res;
1039 }
1040
1041 /*
1042 * Sync on a MJPEG buffer
1043 */
1044
1045 static int
1046 jpg_sync (struct file *file,
1047 struct zoran_sync *bs)
1048 {
1049 struct zoran_fh *fh = file->private_data;
1050 struct zoran *zr = fh->zr;
1051 unsigned long flags;
1052 int frame;
1053
1054 if (fh->jpg_buffers.active == ZORAN_FREE) {
1055 dprintk(1,
1056 KERN_ERR
1057 "%s: jpg_sync() - capture is not currently active\n",
1058 ZR_DEVNAME(zr));
1059 return -EINVAL;
1060 }
1061 if (zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS &&
1062 zr->codec_mode != BUZ_MODE_MOTION_COMPRESS) {
1063 dprintk(1,
1064 KERN_ERR
1065 "%s: jpg_sync() - codec not in streaming mode\n",
1066 ZR_DEVNAME(zr));
1067 return -EINVAL;
1068 }
1069 if (!wait_event_interruptible_timeout(zr->jpg_capq,
1070 (zr->jpg_que_tail != zr->jpg_dma_tail ||
1071 zr->jpg_dma_tail == zr->jpg_dma_head),
1072 10*HZ)) {
1073 int isr;
1074
1075 btand(~ZR36057_JMC_Go_en, ZR36057_JMC);
1076 udelay(1);
1077 zr->codec->control(zr->codec, CODEC_G_STATUS,
1078 sizeof(isr), &isr);
1079 dprintk(1,
1080 KERN_ERR
1081 "%s: jpg_sync() - timeout: codec isr=0x%02x\n",
1082 ZR_DEVNAME(zr), isr);
1083
1084 return -ETIME;
1085
1086 }
1087 if (signal_pending(current))
1088 return -ERESTARTSYS;
1089
1090 spin_lock_irqsave(&zr->spinlock, flags);
1091
1092 if (zr->jpg_dma_tail != zr->jpg_dma_head)
1093 frame = zr->jpg_pend[zr->jpg_que_tail++ & BUZ_MASK_FRAME];
1094 else
1095 frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
1096
1097 /* buffer should now be in BUZ_STATE_DONE */
1098 if (zr->jpg_buffers.buffer[frame].state != BUZ_STATE_DONE)
1099 dprintk(2,
1100 KERN_ERR "%s: jpg_sync() - internal state error\n",
1101 ZR_DEVNAME(zr));
1102
1103 *bs = zr->jpg_buffers.buffer[frame].bs;
1104 bs->frame = frame;
1105 zr->jpg_buffers.buffer[frame].state = BUZ_STATE_USER;
1106 fh->jpg_buffers.buffer[frame] = zr->jpg_buffers.buffer[frame];
1107
1108 spin_unlock_irqrestore(&zr->spinlock, flags);
1109
1110 return 0;
1111 }
1112
1113 static void
1114 zoran_open_init_session (struct file *file)
1115 {
1116 int i;
1117 struct zoran_fh *fh = file->private_data;
1118 struct zoran *zr = fh->zr;
1119
1120 /* Per default, map the V4L Buffers */
1121 fh->map_mode = ZORAN_MAP_MODE_RAW;
1122
1123 /* take over the card's current settings */
1124 fh->overlay_settings = zr->overlay_settings;
1125 fh->overlay_settings.is_set = 0;
1126 fh->overlay_settings.format = zr->overlay_settings.format;
1127 fh->overlay_active = ZORAN_FREE;
1128
1129 /* v4l settings */
1130 fh->v4l_settings = zr->v4l_settings;
1131
1132 /* v4l_buffers */
1133 memset(&fh->v4l_buffers, 0, sizeof(struct zoran_v4l_struct));
1134 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1135 fh->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1136 fh->v4l_buffers.buffer[i].bs.frame = i;
1137 }
1138 fh->v4l_buffers.allocated = 0;
1139 fh->v4l_buffers.ready_to_be_freed = 0;
1140 fh->v4l_buffers.active = ZORAN_FREE;
1141 fh->v4l_buffers.buffer_size = v4l_bufsize;
1142 fh->v4l_buffers.num_buffers = v4l_nbufs;
1143
1144 /* jpg settings */
1145 fh->jpg_settings = zr->jpg_settings;
1146
1147 /* jpg_buffers */
1148 memset(&fh->jpg_buffers, 0, sizeof(struct zoran_jpg_struct));
1149 for (i = 0; i < BUZ_MAX_FRAME; i++) {
1150 fh->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1151 fh->jpg_buffers.buffer[i].bs.frame = i;
1152 }
1153 fh->jpg_buffers.need_contiguous = zr->jpg_buffers.need_contiguous;
1154 fh->jpg_buffers.allocated = 0;
1155 fh->jpg_buffers.ready_to_be_freed = 0;
1156 fh->jpg_buffers.active = ZORAN_FREE;
1157 fh->jpg_buffers.buffer_size = jpg_bufsize;
1158 fh->jpg_buffers.num_buffers = jpg_nbufs;
1159 }
1160
1161 static void
1162 zoran_close_end_session (struct file *file)
1163 {
1164 struct zoran_fh *fh = file->private_data;
1165 struct zoran *zr = fh->zr;
1166
1167 /* overlay */
1168 if (fh->overlay_active != ZORAN_FREE) {
1169 fh->overlay_active = zr->overlay_active = ZORAN_FREE;
1170 zr->v4l_overlay_active = 0;
1171 if (!zr->v4l_memgrab_active)
1172 zr36057_overlay(zr, 0);
1173 zr->overlay_mask = NULL;
1174 }
1175
1176 /* v4l capture */
1177 if (fh->v4l_buffers.active != ZORAN_FREE) {
1178 long flags;
1179
1180 spin_lock_irqsave(&zr->spinlock, flags);
1181 zr36057_set_memgrab(zr, 0);
1182 zr->v4l_buffers.allocated = 0;
1183 zr->v4l_buffers.active = fh->v4l_buffers.active =
1184 ZORAN_FREE;
1185 spin_unlock_irqrestore(&zr->spinlock, flags);
1186 }
1187
1188 /* v4l buffers */
1189 if (fh->v4l_buffers.allocated ||
1190 fh->v4l_buffers.ready_to_be_freed) {
1191 v4l_fbuffer_free(file);
1192 }
1193
1194 /* jpg capture */
1195 if (fh->jpg_buffers.active != ZORAN_FREE) {
1196 zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
1197 zr->jpg_buffers.allocated = 0;
1198 zr->jpg_buffers.active = fh->jpg_buffers.active =
1199 ZORAN_FREE;
1200 }
1201
1202 /* jpg buffers */
1203 if (fh->jpg_buffers.allocated ||
1204 fh->jpg_buffers.ready_to_be_freed) {
1205 jpg_fbuffer_free(file);
1206 }
1207 }
1208
1209 /*
1210 * Open a zoran card. Right now the flags stuff is just playing
1211 */
1212
1213 static int
1214 zoran_open (struct inode *inode,
1215 struct file *file)
1216 {
1217 unsigned int minor = iminor(inode);
1218 struct zoran *zr = NULL;
1219 struct zoran_fh *fh;
1220 int i, res, first_open = 0, have_module_locks = 0;
1221
1222 /* find the device */
1223 for (i = 0; i < zoran_num; i++) {
1224 if (zoran[i].video_dev->minor == minor) {
1225 zr = &zoran[i];
1226 break;
1227 }
1228 }
1229
1230 if (!zr) {
1231 dprintk(1, KERN_ERR "%s: device not found!\n", ZORAN_NAME);
1232 res = -ENODEV;
1233 goto open_unlock_and_return;
1234 }
1235
1236 /* see fs/device.c - the kernel already locks during open(),
1237 * so locking ourselves only causes deadlocks */
1238 /*mutex_lock(&zr->resource_lock);*/
1239
1240 if (!zr->decoder) {
1241 dprintk(1,
1242 KERN_ERR "%s: no TV decoder loaded for device!\n",
1243 ZR_DEVNAME(zr));
1244 res = -EIO;
1245 goto open_unlock_and_return;
1246 }
1247
1248 /* try to grab a module lock */
1249 if (!try_module_get(THIS_MODULE)) {
1250 dprintk(1,
1251 KERN_ERR
1252 "%s: failed to acquire my own lock! PANIC!\n",
1253 ZR_DEVNAME(zr));
1254 res = -ENODEV;
1255 goto open_unlock_and_return;
1256 }
1257 if (!try_module_get(zr->decoder->driver->driver.owner)) {
1258 dprintk(1,
1259 KERN_ERR
1260 "%s: failed to grab ownership of i2c decoder\n",
1261 ZR_DEVNAME(zr));
1262 res = -EIO;
1263 module_put(THIS_MODULE);
1264 goto open_unlock_and_return;
1265 }
1266 if (zr->encoder &&
1267 !try_module_get(zr->encoder->driver->driver.owner)) {
1268 dprintk(1,
1269 KERN_ERR
1270 "%s: failed to grab ownership of i2c encoder\n",
1271 ZR_DEVNAME(zr));
1272 res = -EIO;
1273 module_put(zr->decoder->driver->driver.owner);
1274 module_put(THIS_MODULE);
1275 goto open_unlock_and_return;
1276 }
1277
1278 have_module_locks = 1;
1279
1280 if (zr->user >= 2048) {
1281 dprintk(1, KERN_ERR "%s: too many users (%d) on device\n",
1282 ZR_DEVNAME(zr), zr->user);
1283 res = -EBUSY;
1284 goto open_unlock_and_return;
1285 }
1286
1287 dprintk(1, KERN_INFO "%s: zoran_open(%s, pid=[%d]), users(-)=%d\n",
1288 ZR_DEVNAME(zr), current->comm, task_pid_nr(current), zr->user);
1289
1290 /* now, create the open()-specific file_ops struct */
1291 fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL);
1292 if (!fh) {
1293 dprintk(1,
1294 KERN_ERR
1295 "%s: zoran_open() - allocation of zoran_fh failed\n",
1296 ZR_DEVNAME(zr));
1297 res = -ENOMEM;
1298 goto open_unlock_and_return;
1299 }
1300 /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
1301 * on norm-change! */
1302 fh->overlay_mask =
1303 kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL);
1304 if (!fh->overlay_mask) {
1305 dprintk(1,
1306 KERN_ERR
1307 "%s: zoran_open() - allocation of overlay_mask failed\n",
1308 ZR_DEVNAME(zr));
1309 kfree(fh);
1310 res = -ENOMEM;
1311 goto open_unlock_and_return;
1312 }
1313
1314 if (zr->user++ == 0)
1315 first_open = 1;
1316
1317 /*mutex_unlock(&zr->resource_lock);*/
1318
1319 /* default setup - TODO: look at flags */
1320 if (first_open) { /* First device open */
1321 zr36057_restart(zr);
1322 zoran_open_init_params(zr);
1323 zoran_init_hardware(zr);
1324
1325 btor(ZR36057_ICR_IntPinEn, ZR36057_ICR);
1326 }
1327
1328 /* set file_ops stuff */
1329 file->private_data = fh;
1330 fh->zr = zr;
1331 zoran_open_init_session(file);
1332
1333 return 0;
1334
1335 open_unlock_and_return:
1336 /* if we grabbed locks, release them accordingly */
1337 if (have_module_locks) {
1338 module_put(zr->decoder->driver->driver.owner);
1339 if (zr->encoder) {
1340 module_put(zr->encoder->driver->driver.owner);
1341 }
1342 module_put(THIS_MODULE);
1343 }
1344
1345 /* if there's no device found, we didn't obtain the lock either */
1346 if (zr) {
1347 /*mutex_unlock(&zr->resource_lock);*/
1348 }
1349
1350 return res;
1351 }
1352
1353 static int
1354 zoran_close (struct inode *inode,
1355 struct file *file)
1356 {
1357 struct zoran_fh *fh = file->private_data;
1358 struct zoran *zr = fh->zr;
1359
1360 dprintk(1, KERN_INFO "%s: zoran_close(%s, pid=[%d]), users(+)=%d\n",
1361 ZR_DEVNAME(zr), current->comm, task_pid_nr(current), zr->user);
1362
1363 /* kernel locks (fs/device.c), so don't do that ourselves
1364 * (prevents deadlocks) */
1365 /*mutex_lock(&zr->resource_lock);*/
1366
1367 zoran_close_end_session(file);
1368
1369 if (zr->user-- == 1) { /* Last process */
1370 /* Clean up JPEG process */
1371 wake_up_interruptible(&zr->jpg_capq);
1372 zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
1373 zr->jpg_buffers.allocated = 0;
1374 zr->jpg_buffers.active = ZORAN_FREE;
1375
1376 /* disable interrupts */
1377 btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);
1378
1379 if (zr36067_debug > 1)
1380 print_interrupts(zr);
1381
1382 /* Overlay off */
1383 zr->v4l_overlay_active = 0;
1384 zr36057_overlay(zr, 0);
1385 zr->overlay_mask = NULL;
1386
1387 /* capture off */
1388 wake_up_interruptible(&zr->v4l_capq);
1389 zr36057_set_memgrab(zr, 0);
1390 zr->v4l_buffers.allocated = 0;
1391 zr->v4l_buffers.active = ZORAN_FREE;
1392 zoran_set_pci_master(zr, 0);
1393
1394 if (!pass_through) { /* Switch to color bar */
1395 int zero = 0, two = 2;
1396 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1397 encoder_command(zr, ENCODER_SET_INPUT, &two);
1398 }
1399 }
1400
1401 file->private_data = NULL;
1402 kfree(fh->overlay_mask);
1403 kfree(fh);
1404
1405 /* release locks on the i2c modules */
1406 module_put(zr->decoder->driver->driver.owner);
1407 if (zr->encoder) {
1408 module_put(zr->encoder->driver->driver.owner);
1409 }
1410 module_put(THIS_MODULE);
1411
1412 /*mutex_unlock(&zr->resource_lock);*/
1413
1414 dprintk(4, KERN_INFO "%s: zoran_close() done\n", ZR_DEVNAME(zr));
1415
1416 return 0;
1417 }
1418
1419
1420 static ssize_t
1421 zoran_read (struct file *file,
1422 char __user *data,
1423 size_t count,
1424 loff_t *ppos)
1425 {
1426 /* we simply don't support read() (yet)... */
1427
1428 return -EINVAL;
1429 }
1430
1431 static ssize_t
1432 zoran_write (struct file *file,
1433 const char __user *data,
1434 size_t count,
1435 loff_t *ppos)
1436 {
1437 /* ...and the same goes for write() */
1438
1439 return -EINVAL;
1440 }
1441
1442 static int
1443 setup_fbuffer (struct file *file,
1444 void *base,
1445 const struct zoran_format *fmt,
1446 int width,
1447 int height,
1448 int bytesperline)
1449 {
1450 struct zoran_fh *fh = file->private_data;
1451 struct zoran *zr = fh->zr;
1452
1453 /* (Ronald) v4l/v4l2 guidelines */
1454 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
1455 return -EPERM;
1456
1457 /* Don't allow frame buffer overlay if PCI or AGP is buggy, or on
1458 ALi Magik (that needs very low latency while the card needs a
1459 higher value always) */
1460
1461 if (pci_pci_problems & (PCIPCI_FAIL | PCIAGP_FAIL | PCIPCI_ALIMAGIK))
1462 return -ENXIO;
1463
1464 /* we need a bytesperline value, even if not given */
1465 if (!bytesperline)
1466 bytesperline = width * ((fmt->depth + 7) & ~7) / 8;
1467
1468 #if 0
1469 if (zr->overlay_active) {
1470 /* dzjee... stupid users... don't even bother to turn off
1471 * overlay before changing the memory location...
1472 * normally, we would return errors here. However, one of
1473 * the tools that does this is... xawtv! and since xawtv
1474 * is used by +/- 99% of the users, we'd rather be user-
1475 * friendly and silently do as if nothing went wrong */
1476 dprintk(3,
1477 KERN_ERR
1478 "%s: setup_fbuffer() - forced overlay turnoff because framebuffer changed\n",
1479 ZR_DEVNAME(zr));
1480 zr36057_overlay(zr, 0);
1481 }
1482 #endif
1483
1484 if (!(fmt->flags & ZORAN_FORMAT_OVERLAY)) {
1485 dprintk(1,
1486 KERN_ERR
1487 "%s: setup_fbuffer() - no valid overlay format given\n",
1488 ZR_DEVNAME(zr));
1489 return -EINVAL;
1490 }
1491 if (height <= 0 || width <= 0 || bytesperline <= 0) {
1492 dprintk(1,
1493 KERN_ERR
1494 "%s: setup_fbuffer() - invalid height/width/bpl value (%d|%d|%d)\n",
1495 ZR_DEVNAME(zr), width, height, bytesperline);
1496 return -EINVAL;
1497 }
1498 if (bytesperline & 3) {
1499 dprintk(1,
1500 KERN_ERR
1501 "%s: setup_fbuffer() - bytesperline (%d) must be 4-byte aligned\n",
1502 ZR_DEVNAME(zr), bytesperline);
1503 return -EINVAL;
1504 }
1505
1506 zr->buffer.base = (void *) ((unsigned long) base & ~3);
1507 zr->buffer.height = height;
1508 zr->buffer.width = width;
1509 zr->buffer.depth = fmt->depth;
1510 zr->overlay_settings.format = fmt;
1511 zr->buffer.bytesperline = bytesperline;
1512
1513 /* The user should set new window parameters */
1514 zr->overlay_settings.is_set = 0;
1515
1516 return 0;
1517 }
1518
1519
1520 static int
1521 setup_window (struct file *file,
1522 int x,
1523 int y,
1524 int width,
1525 int height,
1526 struct video_clip __user *clips,
1527 int clipcount,
1528 void __user *bitmap)
1529 {
1530 struct zoran_fh *fh = file->private_data;
1531 struct zoran *zr = fh->zr;
1532 struct video_clip *vcp = NULL;
1533 int on, end;
1534
1535
1536 if (!zr->buffer.base) {
1537 dprintk(1,
1538 KERN_ERR
1539 "%s: setup_window() - frame buffer has to be set first\n",
1540 ZR_DEVNAME(zr));
1541 return -EINVAL;
1542 }
1543
1544 if (!fh->overlay_settings.format) {
1545 dprintk(1,
1546 KERN_ERR
1547 "%s: setup_window() - no overlay format set\n",
1548 ZR_DEVNAME(zr));
1549 return -EINVAL;
1550 }
1551
1552 /*
1553 * The video front end needs 4-byte alinged line sizes, we correct that
1554 * silently here if necessary
1555 */
1556 if (zr->buffer.depth == 15 || zr->buffer.depth == 16) {
1557 end = (x + width) & ~1; /* round down */
1558 x = (x + 1) & ~1; /* round up */
1559 width = end - x;
1560 }
1561
1562 if (zr->buffer.depth == 24) {
1563 end = (x + width) & ~3; /* round down */
1564 x = (x + 3) & ~3; /* round up */
1565 width = end - x;
1566 }
1567
1568 if (width > BUZ_MAX_WIDTH)
1569 width = BUZ_MAX_WIDTH;
1570 if (height > BUZ_MAX_HEIGHT)
1571 height = BUZ_MAX_HEIGHT;
1572
1573 /* Check for vaild parameters */
1574 if (width < BUZ_MIN_WIDTH || height < BUZ_MIN_HEIGHT ||
1575 width > BUZ_MAX_WIDTH || height > BUZ_MAX_HEIGHT) {
1576 dprintk(1,
1577 KERN_ERR
1578 "%s: setup_window() - width = %d or height = %d invalid\n",
1579 ZR_DEVNAME(zr), width, height);
1580 return -EINVAL;
1581 }
1582
1583 fh->overlay_settings.x = x;
1584 fh->overlay_settings.y = y;
1585 fh->overlay_settings.width = width;
1586 fh->overlay_settings.height = height;
1587 fh->overlay_settings.clipcount = clipcount;
1588
1589 /*
1590 * If an overlay is running, we have to switch it off
1591 * and switch it on again in order to get the new settings in effect.
1592 *
1593 * We also want to avoid that the overlay mask is written
1594 * when an overlay is running.
1595 */
1596
1597 on = zr->v4l_overlay_active && !zr->v4l_memgrab_active &&
1598 zr->overlay_active != ZORAN_FREE &&
1599 fh->overlay_active != ZORAN_FREE;
1600 if (on)
1601 zr36057_overlay(zr, 0);
1602
1603 /*
1604 * Write the overlay mask if clips are wanted.
1605 * We prefer a bitmap.
1606 */
1607 if (bitmap) {
1608 /* fake value - it just means we want clips */
1609 fh->overlay_settings.clipcount = 1;
1610
1611 if (copy_from_user(fh->overlay_mask, bitmap,
1612 (width * height + 7) / 8)) {
1613 return -EFAULT;
1614 }
1615 } else if (clipcount > 0) {
1616 /* write our own bitmap from the clips */
1617 vcp = vmalloc(sizeof(struct video_clip) * (clipcount + 4));
1618 if (vcp == NULL) {
1619 dprintk(1,
1620 KERN_ERR
1621 "%s: setup_window() - Alloc of clip mask failed\n",
1622 ZR_DEVNAME(zr));
1623 return -ENOMEM;
1624 }
1625 if (copy_from_user
1626 (vcp, clips, sizeof(struct video_clip) * clipcount)) {
1627 vfree(vcp);
1628 return -EFAULT;
1629 }
1630 write_overlay_mask(file, vcp, clipcount);
1631 vfree(vcp);
1632 }
1633
1634 fh->overlay_settings.is_set = 1;
1635 if (fh->overlay_active != ZORAN_FREE &&
1636 zr->overlay_active != ZORAN_FREE)
1637 zr->overlay_settings = fh->overlay_settings;
1638
1639 if (on)
1640 zr36057_overlay(zr, 1);
1641
1642 /* Make sure the changes come into effect */
1643 return wait_grab_pending(zr);
1644 }
1645
1646 static int
1647 setup_overlay (struct file *file,
1648 int on)
1649 {
1650 struct zoran_fh *fh = file->private_data;
1651 struct zoran *zr = fh->zr;
1652
1653 /* If there is nothing to do, return immediatly */
1654 if ((on && fh->overlay_active != ZORAN_FREE) ||
1655 (!on && fh->overlay_active == ZORAN_FREE))
1656 return 0;
1657
1658 /* check whether we're touching someone else's overlay */
1659 if (on && zr->overlay_active != ZORAN_FREE &&
1660 fh->overlay_active == ZORAN_FREE) {
1661 dprintk(1,
1662 KERN_ERR
1663 "%s: setup_overlay() - overlay is already active for another session\n",
1664 ZR_DEVNAME(zr));
1665 return -EBUSY;
1666 }
1667 if (!on && zr->overlay_active != ZORAN_FREE &&
1668 fh->overlay_active == ZORAN_FREE) {
1669 dprintk(1,
1670 KERN_ERR
1671 "%s: setup_overlay() - you cannot cancel someone else's session\n",
1672 ZR_DEVNAME(zr));
1673 return -EPERM;
1674 }
1675
1676 if (on == 0) {
1677 zr->overlay_active = fh->overlay_active = ZORAN_FREE;
1678 zr->v4l_overlay_active = 0;
1679 /* When a grab is running, the video simply
1680 * won't be switched on any more */
1681 if (!zr->v4l_memgrab_active)
1682 zr36057_overlay(zr, 0);
1683 zr->overlay_mask = NULL;
1684 } else {
1685 if (!zr->buffer.base || !fh->overlay_settings.is_set) {
1686 dprintk(1,
1687 KERN_ERR
1688 "%s: setup_overlay() - buffer or window not set\n",
1689 ZR_DEVNAME(zr));
1690 return -EINVAL;
1691 }
1692 if (!fh->overlay_settings.format) {
1693 dprintk(1,
1694 KERN_ERR
1695 "%s: setup_overlay() - no overlay format set\n",
1696 ZR_DEVNAME(zr));
1697 return -EINVAL;
1698 }
1699 zr->overlay_active = fh->overlay_active = ZORAN_LOCKED;
1700 zr->v4l_overlay_active = 1;
1701 zr->overlay_mask = fh->overlay_mask;
1702 zr->overlay_settings = fh->overlay_settings;
1703 if (!zr->v4l_memgrab_active)
1704 zr36057_overlay(zr, 1);
1705 /* When a grab is running, the video will be
1706 * switched on when grab is finished */
1707 }
1708
1709 /* Make sure the changes come into effect */
1710 return wait_grab_pending(zr);
1711 }
1712
1713 #ifdef CONFIG_VIDEO_V4L2
1714 /* get the status of a buffer in the clients buffer queue */
1715 static int
1716 zoran_v4l2_buffer_status (struct file *file,
1717 struct v4l2_buffer *buf,
1718 int num)
1719 {
1720 struct zoran_fh *fh = file->private_data;
1721 struct zoran *zr = fh->zr;
1722
1723 buf->flags = V4L2_BUF_FLAG_MAPPED;
1724
1725 switch (fh->map_mode) {
1726 case ZORAN_MAP_MODE_RAW:
1727
1728 /* check range */
1729 if (num < 0 || num >= fh->v4l_buffers.num_buffers ||
1730 !fh->v4l_buffers.allocated) {
1731 dprintk(1,
1732 KERN_ERR
1733 "%s: v4l2_buffer_status() - wrong number or buffers not allocated\n",
1734 ZR_DEVNAME(zr));
1735 return -EINVAL;
1736 }
1737
1738 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1739 buf->length = fh->v4l_buffers.buffer_size;
1740
1741 /* get buffer */
1742 buf->bytesused = fh->v4l_buffers.buffer[num].bs.length;
1743 if (fh->v4l_buffers.buffer[num].state == BUZ_STATE_DONE ||
1744 fh->v4l_buffers.buffer[num].state == BUZ_STATE_USER) {
1745 buf->sequence = fh->v4l_buffers.buffer[num].bs.seq;
1746 buf->flags |= V4L2_BUF_FLAG_DONE;
1747 buf->timestamp =
1748 fh->v4l_buffers.buffer[num].bs.timestamp;
1749 } else {
1750 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1751 }
1752
1753 if (fh->v4l_settings.height <= BUZ_MAX_HEIGHT / 2)
1754 buf->field = V4L2_FIELD_TOP;
1755 else
1756 buf->field = V4L2_FIELD_INTERLACED;
1757
1758 break;
1759
1760 case ZORAN_MAP_MODE_JPG_REC:
1761 case ZORAN_MAP_MODE_JPG_PLAY:
1762
1763 /* check range */
1764 if (num < 0 || num >= fh->jpg_buffers.num_buffers ||
1765 !fh->jpg_buffers.allocated) {
1766 dprintk(1,
1767 KERN_ERR
1768 "%s: v4l2_buffer_status() - wrong number or buffers not allocated\n",
1769 ZR_DEVNAME(zr));
1770 return -EINVAL;
1771 }
1772
1773 buf->type = (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?
1774 V4L2_BUF_TYPE_VIDEO_CAPTURE :
1775 V4L2_BUF_TYPE_VIDEO_OUTPUT;
1776 buf->length = fh->jpg_buffers.buffer_size;
1777
1778 /* these variables are only written after frame has been captured */
1779 if (fh->jpg_buffers.buffer[num].state == BUZ_STATE_DONE ||
1780 fh->jpg_buffers.buffer[num].state == BUZ_STATE_USER) {
1781 buf->sequence = fh->jpg_buffers.buffer[num].bs.seq;
1782 buf->timestamp =
1783 fh->jpg_buffers.buffer[num].bs.timestamp;
1784 buf->bytesused =
1785 fh->jpg_buffers.buffer[num].bs.length;
1786 buf->flags |= V4L2_BUF_FLAG_DONE;
1787 } else {
1788 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1789 }
1790
1791 /* which fields are these? */
1792 if (fh->jpg_settings.TmpDcm != 1)
1793 buf->field =
1794 fh->jpg_settings.
1795 odd_even ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
1796 else
1797 buf->field =
1798 fh->jpg_settings.
1799 odd_even ? V4L2_FIELD_SEQ_TB :
1800 V4L2_FIELD_SEQ_BT;
1801
1802 break;
1803
1804 default:
1805
1806 dprintk(5,
1807 KERN_ERR
1808 "%s: v4l2_buffer_status() - invalid buffer type|map_mode (%d|%d)\n",
1809 ZR_DEVNAME(zr), buf->type, fh->map_mode);
1810 return -EINVAL;
1811 }
1812
1813 buf->memory = V4L2_MEMORY_MMAP;
1814 buf->index = num;
1815 buf->m.offset = buf->length * num;
1816
1817 return 0;
1818 }
1819 #endif
1820
1821 static int
1822 zoran_set_norm (struct zoran *zr,
1823 int norm) /* VIDEO_MODE_* */
1824 {
1825 int norm_encoder, on;
1826
1827 if (zr->v4l_buffers.active != ZORAN_FREE ||
1828 zr->jpg_buffers.active != ZORAN_FREE) {
1829 dprintk(1,
1830 KERN_WARNING
1831 "%s: set_norm() called while in playback/capture mode\n",
1832 ZR_DEVNAME(zr));
1833 return -EBUSY;
1834 }
1835
1836 if (lock_norm && norm != zr->norm) {
1837 if (lock_norm > 1) {
1838 dprintk(1,
1839 KERN_WARNING
1840 "%s: set_norm() - TV standard is locked, can not switch norm\n",
1841 ZR_DEVNAME(zr));
1842 return -EPERM;
1843 } else {
1844 dprintk(1,
1845 KERN_WARNING
1846 "%s: set_norm() - TV standard is locked, norm was not changed\n",
1847 ZR_DEVNAME(zr));
1848 norm = zr->norm;
1849 }
1850 }
1851
1852 if (norm != VIDEO_MODE_AUTO &&
1853 (norm < 0 || norm >= zr->card.norms ||
1854 !zr->card.tvn[norm])) {
1855 dprintk(1,
1856 KERN_ERR "%s: set_norm() - unsupported norm %d\n",
1857 ZR_DEVNAME(zr), norm);
1858 return -EINVAL;
1859 }
1860
1861 if (norm == VIDEO_MODE_AUTO) {
1862 int status;
1863
1864 /* if we have autodetect, ... */
1865 struct video_decoder_capability caps;
1866 decoder_command(zr, DECODER_GET_CAPABILITIES, &caps);
1867 if (!(caps.flags & VIDEO_DECODER_AUTO)) {
1868 dprintk(1, KERN_ERR "%s: norm=auto unsupported\n",
1869 ZR_DEVNAME(zr));
1870 return -EINVAL;
1871 }
1872
1873 decoder_command(zr, DECODER_SET_NORM, &norm);
1874
1875 /* let changes come into effect */
1876 ssleep(2);
1877
1878 decoder_command(zr, DECODER_GET_STATUS, &status);
1879 if (!(status & DECODER_STATUS_GOOD)) {
1880 dprintk(1,
1881 KERN_ERR
1882 "%s: set_norm() - no norm detected\n",
1883 ZR_DEVNAME(zr));
1884 /* reset norm */
1885 decoder_command(zr, DECODER_SET_NORM, &zr->norm);
1886 return -EIO;
1887 }
1888
1889 if (status & DECODER_STATUS_NTSC)
1890 norm = VIDEO_MODE_NTSC;
1891 else if (status & DECODER_STATUS_SECAM)
1892 norm = VIDEO_MODE_SECAM;
1893 else
1894 norm = VIDEO_MODE_PAL;
1895 }
1896 zr->timing = zr->card.tvn[norm];
1897 norm_encoder = norm;
1898
1899 /* We switch overlay off and on since a change in the
1900 * norm needs different VFE settings */
1901 on = zr->overlay_active && !zr->v4l_memgrab_active;
1902 if (on)
1903 zr36057_overlay(zr, 0);
1904
1905 decoder_command(zr, DECODER_SET_NORM, &norm);
1906 encoder_command(zr, ENCODER_SET_NORM, &norm_encoder);
1907
1908 if (on)
1909 zr36057_overlay(zr, 1);
1910
1911 /* Make sure the changes come into effect */
1912 zr->norm = norm;
1913
1914 return 0;
1915 }
1916
1917 static int
1918 zoran_set_input (struct zoran *zr,
1919 int input)
1920 {
1921 int realinput;
1922
1923 if (input == zr->input) {
1924 return 0;
1925 }
1926
1927 if (zr->v4l_buffers.active != ZORAN_FREE ||
1928 zr->jpg_buffers.active != ZORAN_FREE) {
1929 dprintk(1,
1930 KERN_WARNING
1931 "%s: set_input() called while in playback/capture mode\n",
1932 ZR_DEVNAME(zr));
1933 return -EBUSY;
1934 }
1935
1936 if (input < 0 || input >= zr->card.inputs) {
1937 dprintk(1,
1938 KERN_ERR
1939 "%s: set_input() - unnsupported input %d\n",
1940 ZR_DEVNAME(zr), input);
1941 return -EINVAL;
1942 }
1943
1944 realinput = zr->card.input[input].muxsel;
1945 zr->input = input;
1946
1947 decoder_command(zr, DECODER_SET_INPUT, &realinput);
1948
1949 return 0;
1950 }
1951
1952 /*
1953 * ioctl routine
1954 */
1955
1956 static int
1957 zoran_do_ioctl (struct inode *inode,
1958 struct file *file,
1959 unsigned int cmd,
1960 void *arg)
1961 {
1962 struct zoran_fh *fh = file->private_data;
1963 struct zoran *zr = fh->zr;
1964 /* CAREFUL: used in multiple places here */
1965 struct zoran_jpg_settings settings;
1966
1967 /* we might have older buffers lying around... We don't want
1968 * to wait, but we do want to try cleaning them up ASAP. So
1969 * we try to obtain the lock and free them. If that fails, we
1970 * don't do anything and wait for the next turn. In the end,
1971 * zoran_close() or a new allocation will still free them...
1972 * This is just a 'the sooner the better' extra 'feature'
1973 *
1974 * We don't free the buffers right on munmap() because that
1975 * causes oopses (kfree() inside munmap() oopses for no
1976 * apparent reason - it's also not reproduceable in any way,
1977 * but moving the free code outside the munmap() handler fixes
1978 * all this... If someone knows why, please explain me (Ronald)
1979 */
1980 if (mutex_trylock(&zr->resource_lock)) {
1981 /* we obtained it! Let's try to free some things */
1982 if (fh->jpg_buffers.ready_to_be_freed)
1983 jpg_fbuffer_free(file);
1984 if (fh->v4l_buffers.ready_to_be_freed)
1985 v4l_fbuffer_free(file);
1986
1987 mutex_unlock(&zr->resource_lock);
1988 }
1989
1990 switch (cmd) {
1991
1992 case VIDIOCGCAP:
1993 {
1994 struct video_capability *vcap = arg;
1995
1996 dprintk(3, KERN_DEBUG "%s: VIDIOCGCAP\n", ZR_DEVNAME(zr));
1997
1998 memset(vcap, 0, sizeof(struct video_capability));
1999 strncpy(vcap->name, ZR_DEVNAME(zr), sizeof(vcap->name)-1);
2000 vcap->type = ZORAN_VID_TYPE;
2001
2002 vcap->channels = zr->card.inputs;
2003 vcap->audios = 0;
2004 mutex_lock(&zr->resource_lock);
2005 vcap->maxwidth = BUZ_MAX_WIDTH;
2006 vcap->maxheight = BUZ_MAX_HEIGHT;
2007 vcap->minwidth = BUZ_MIN_WIDTH;
2008 vcap->minheight = BUZ_MIN_HEIGHT;
2009 mutex_unlock(&zr->resource_lock);
2010
2011 return 0;
2012 }
2013 break;
2014
2015 case VIDIOCGCHAN:
2016 {
2017 struct video_channel *vchan = arg;
2018 int channel = vchan->channel;
2019
2020 dprintk(3, KERN_DEBUG "%s: VIDIOCGCHAN - channel=%d\n",
2021 ZR_DEVNAME(zr), vchan->channel);
2022
2023 memset(vchan, 0, sizeof(struct video_channel));
2024 if (channel > zr->card.inputs || channel < 0) {
2025 dprintk(1,
2026 KERN_ERR
2027 "%s: VIDIOCGCHAN on not existing channel %d\n",
2028 ZR_DEVNAME(zr), channel);
2029 return -EINVAL;
2030 }
2031
2032 strcpy(vchan->name, zr->card.input[channel].name);
2033
2034 vchan->tuners = 0;
2035 vchan->flags = 0;
2036 vchan->type = VIDEO_TYPE_CAMERA;
2037 mutex_lock(&zr->resource_lock);
2038 vchan->norm = zr->norm;
2039 mutex_unlock(&zr->resource_lock);
2040 vchan->channel = channel;
2041
2042 return 0;
2043 }
2044 break;
2045
2046 /* RJ: the documentation at http://roadrunner.swansea.linux.org.uk/v4lapi.shtml says:
2047 *
2048 * * "The VIDIOCSCHAN ioctl takes an integer argument and switches the capture to this input."
2049 * * ^^^^^^^
2050 * * The famos BTTV driver has it implemented with a struct video_channel argument
2051 * * and we follow it for compatibility reasons
2052 * *
2053 * * BTW: this is the only way the user can set the norm!
2054 */
2055
2056 case VIDIOCSCHAN:
2057 {
2058 struct video_channel *vchan = arg;
2059 int res;
2060
2061 dprintk(3,
2062 KERN_DEBUG
2063 "%s: VIDIOCSCHAN - channel=%d, norm=%d\n",
2064 ZR_DEVNAME(zr), vchan->channel, vchan->norm);
2065
2066 mutex_lock(&zr->resource_lock);
2067 if ((res = zoran_set_input(zr, vchan->channel)))
2068 goto schan_unlock_and_return;
2069 if ((res = zoran_set_norm(zr, vchan->norm)))
2070 goto schan_unlock_and_return;
2071
2072 /* Make sure the changes come into effect */
2073 res = wait_grab_pending(zr);
2074 schan_unlock_and_return:
2075 mutex_unlock(&zr->resource_lock);
2076 return res;
2077 }
2078 break;
2079
2080 case VIDIOCGPICT:
2081 {
2082 struct video_picture *vpict = arg;
2083
2084 dprintk(3, KERN_DEBUG "%s: VIDIOCGPICT\n", ZR_DEVNAME(zr));
2085
2086 memset(vpict, 0, sizeof(struct video_picture));
2087 mutex_lock(&zr->resource_lock);
2088 vpict->hue = zr->hue;
2089 vpict->brightness = zr->brightness;
2090 vpict->contrast = zr->contrast;
2091 vpict->colour = zr->saturation;
2092 if (fh->overlay_settings.format) {
2093 vpict->depth = fh->overlay_settings.format->depth;
2094 vpict->palette = fh->overlay_settings.format->palette;
2095 } else {
2096 vpict->depth = 0;
2097 }
2098 mutex_unlock(&zr->resource_lock);
2099
2100 return 0;
2101 }
2102 break;
2103
2104 case VIDIOCSPICT:
2105 {
2106 struct video_picture *vpict = arg;
2107 int i;
2108
2109 dprintk(3,
2110 KERN_DEBUG
2111 "%s: VIDIOCSPICT - bri=%d, hue=%d, col=%d, con=%d, dep=%d, pal=%d\n",
2112 ZR_DEVNAME(zr), vpict->brightness, vpict->hue,
2113 vpict->colour, vpict->contrast, vpict->depth,
2114 vpict->palette);
2115
2116 for (i = 0; i < NUM_FORMATS; i++) {
2117 const struct zoran_format *fmt = &zoran_formats[i];
2118
2119 if (fmt->palette != -1 &&
2120 fmt->flags & ZORAN_FORMAT_OVERLAY &&
2121 fmt->palette == vpict->palette &&
2122 fmt->depth == vpict->depth)
2123 break;
2124 }
2125 if (i == NUM_FORMATS) {
2126 dprintk(1,
2127 KERN_ERR
2128 "%s: VIDIOCSPICT - Invalid palette %d\n",
2129 ZR_DEVNAME(zr), vpict->palette);
2130 return -EINVAL;
2131 }
2132
2133 mutex_lock(&zr->resource_lock);
2134
2135 decoder_command(zr, DECODER_SET_PICTURE, vpict);
2136
2137 zr->hue = vpict->hue;
2138 zr->contrast = vpict->contrast;
2139 zr->saturation = vpict->colour;
2140 zr->brightness = vpict->brightness;
2141
2142 fh->overlay_settings.format = &zoran_formats[i];
2143
2144 mutex_unlock(&zr->resource_lock);
2145
2146 return 0;
2147 }
2148 break;
2149
2150 case VIDIOCCAPTURE:
2151 {
2152 int *on = arg, res;
2153
2154 dprintk(3, KERN_DEBUG "%s: VIDIOCCAPTURE - on=%d\n",
2155 ZR_DEVNAME(zr), *on);
2156
2157 mutex_lock(&zr->resource_lock);
2158 res = setup_overlay(file, *on);
2159 mutex_unlock(&zr->resource_lock);
2160
2161 return res;
2162 }
2163 break;
2164
2165 case VIDIOCGWIN:
2166 {
2167 struct video_window *vwin = arg;
2168
2169 dprintk(3, KERN_DEBUG "%s: VIDIOCGWIN\n", ZR_DEVNAME(zr));
2170
2171 memset(vwin, 0, sizeof(struct video_window));
2172 mutex_lock(&zr->resource_lock);
2173 vwin->x = fh->overlay_settings.x;
2174 vwin->y = fh->overlay_settings.y;
2175 vwin->width = fh->overlay_settings.width;
2176 vwin->height = fh->overlay_settings.height;
2177 mutex_unlock(&zr->resource_lock);
2178 vwin->clipcount = 0;
2179 return 0;
2180 }
2181 break;
2182
2183 case VIDIOCSWIN:
2184 {
2185 struct video_window *vwin = arg;
2186 int res;
2187
2188 dprintk(3,
2189 KERN_DEBUG
2190 "%s: VIDIOCSWIN - x=%d, y=%d, w=%d, h=%d, clipcount=%d\n",
2191 ZR_DEVNAME(zr), vwin->x, vwin->y, vwin->width,
2192 vwin->height, vwin->clipcount);
2193
2194 mutex_lock(&zr->resource_lock);
2195 res =
2196 setup_window(file, vwin->x, vwin->y, vwin->width,
2197 vwin->height, vwin->clips,
2198 vwin->clipcount, NULL);
2199 mutex_unlock(&zr->resource_lock);
2200
2201 return res;
2202 }
2203 break;
2204
2205 case VIDIOCGFBUF:
2206 {
2207 struct video_buffer *vbuf = arg;
2208
2209 dprintk(3, KERN_DEBUG "%s: VIDIOCGFBUF\n", ZR_DEVNAME(zr));
2210
2211 mutex_lock(&zr->resource_lock);
2212 *vbuf = zr->buffer;
2213 mutex_unlock(&zr->resource_lock);
2214 return 0;
2215 }
2216 break;
2217
2218 case VIDIOCSFBUF:
2219 {
2220 struct video_buffer *vbuf = arg;
2221 int i, res = 0;
2222
2223 dprintk(3,
2224 KERN_DEBUG
2225 "%s: VIDIOCSFBUF - base=%p, w=%d, h=%d, depth=%d, bpl=%d\n",
2226 ZR_DEVNAME(zr), vbuf->base, vbuf->width,
2227 vbuf->height, vbuf->depth, vbuf->bytesperline);
2228
2229 for (i = 0; i < NUM_FORMATS; i++)
2230 if (zoran_formats[i].depth == vbuf->depth)
2231 break;
2232 if (i == NUM_FORMATS) {
2233 dprintk(1,
2234 KERN_ERR
2235 "%s: VIDIOCSFBUF - invalid fbuf depth %d\n",
2236 ZR_DEVNAME(zr), vbuf->depth);
2237 return -EINVAL;
2238 }
2239
2240 mutex_lock(&zr->resource_lock);
2241 res =
2242 setup_fbuffer(file, vbuf->base, &zoran_formats[i],
2243 vbuf->width, vbuf->height,
2244 vbuf->bytesperline);
2245 mutex_unlock(&zr->resource_lock);
2246
2247 return res;
2248 }
2249 break;
2250
2251 case VIDIOCSYNC:
2252 {
2253 int *frame = arg, res;
2254
2255 dprintk(3, KERN_DEBUG "%s: VIDIOCSYNC - frame=%d\n",
2256 ZR_DEVNAME(zr), *frame);
2257
2258 mutex_lock(&zr->resource_lock);
2259 res = v4l_sync(file, *frame);
2260 mutex_unlock(&zr->resource_lock);
2261 if (!res)
2262 zr->v4l_sync_tail++;
2263 return res;
2264 }
2265 break;
2266
2267 case VIDIOCMCAPTURE:
2268 {
2269 struct video_mmap *vmap = arg;
2270 int res;
2271
2272 dprintk(3,
2273 KERN_DEBUG
2274 "%s: VIDIOCMCAPTURE - frame=%d, geom=%dx%d, fmt=%d\n",
2275 ZR_DEVNAME(zr), vmap->frame, vmap->width, vmap->height,
2276 vmap->format);
2277
2278 mutex_lock(&zr->resource_lock);
2279 res = v4l_grab(file, vmap);
2280 mutex_unlock(&zr->resource_lock);
2281 return res;
2282 }
2283 break;
2284
2285 case VIDIOCGMBUF:
2286 {
2287 struct video_mbuf *vmbuf = arg;
2288 int i, res = 0;
2289
2290 dprintk(3, KERN_DEBUG "%s: VIDIOCGMBUF\n", ZR_DEVNAME(zr));
2291
2292 vmbuf->size =
2293 fh->v4l_buffers.num_buffers *
2294 fh->v4l_buffers.buffer_size;
2295 vmbuf->frames = fh->v4l_buffers.num_buffers;
2296 for (i = 0; i < vmbuf->frames; i++) {
2297 vmbuf->offsets[i] =
2298 i * fh->v4l_buffers.buffer_size;
2299 }
2300
2301 mutex_lock(&zr->resource_lock);
2302
2303 if (fh->jpg_buffers.allocated || fh->v4l_buffers.allocated) {
2304 dprintk(1,
2305 KERN_ERR
2306 "%s: VIDIOCGMBUF - buffers already allocated\n",
2307 ZR_DEVNAME(zr));
2308 res = -EINVAL;
2309 goto v4l1reqbuf_unlock_and_return;
2310 }
2311
2312 if (v4l_fbuffer_alloc(file)) {
2313 res = -ENOMEM;
2314 goto v4l1reqbuf_unlock_and_return;
2315 }
2316
2317 /* The next mmap will map the V4L buffers */
2318 fh->map_mode = ZORAN_MAP_MODE_RAW;
2319 v4l1reqbuf_unlock_and_return:
2320 mutex_unlock(&zr->resource_lock);
2321
2322 return res;
2323 }
2324 break;
2325
2326 case VIDIOCGUNIT:
2327 {
2328 struct video_unit *vunit = arg;
2329
2330 dprintk(3, KERN_DEBUG "%s: VIDIOCGUNIT\n", ZR_DEVNAME(zr));
2331
2332 vunit->video = zr->video_dev->minor;
2333 vunit->vbi = VIDEO_NO_UNIT;
2334 vunit->radio = VIDEO_NO_UNIT;
2335 vunit->audio = VIDEO_NO_UNIT;
2336 vunit->teletext = VIDEO_NO_UNIT;
2337
2338 return 0;
2339 }
2340 break;
2341
2342 /*
2343 * RJ: In principal we could support subcaptures for V4L grabbing.
2344 * Not even the famous BTTV driver has them, however.
2345 * If there should be a strong demand, one could consider
2346 * to implement them.
2347 */
2348 case VIDIOCGCAPTURE:
2349 {
2350 dprintk(3, KERN_ERR "%s: VIDIOCGCAPTURE not supported\n",
2351 ZR_DEVNAME(zr));
2352 return -EINVAL;
2353 }
2354 break;
2355
2356 case VIDIOCSCAPTURE:
2357 {
2358 dprintk(3, KERN_ERR "%s: VIDIOCSCAPTURE not supported\n",
2359 ZR_DEVNAME(zr));
2360 return -EINVAL;
2361 }
2362 break;
2363
2364 case BUZIOC_G_PARAMS:
2365 {
2366 struct zoran_params *bparams = arg;
2367
2368 dprintk(3, KERN_DEBUG "%s: BUZIOC_G_PARAMS\n", ZR_DEVNAME(zr));
2369
2370 memset(bparams, 0, sizeof(struct zoran_params));
2371 bparams->major_version = MAJOR_VERSION;
2372 bparams->minor_version = MINOR_VERSION;
2373
2374 mutex_lock(&zr->resource_lock);
2375
2376 bparams->norm = zr->norm;
2377 bparams->input = zr->input;
2378
2379 bparams->decimation = fh->jpg_settings.decimation;
2380 bparams->HorDcm = fh->jpg_settings.HorDcm;
2381 bparams->VerDcm = fh->jpg_settings.VerDcm;
2382 bparams->TmpDcm = fh->jpg_settings.TmpDcm;
2383 bparams->field_per_buff = fh->jpg_settings.field_per_buff;
2384 bparams->img_x = fh->jpg_settings.img_x;
2385 bparams->img_y = fh->jpg_settings.img_y;
2386 bparams->img_width = fh->jpg_settings.img_width;
2387 bparams->img_height = fh->jpg_settings.img_height;
2388 bparams->odd_even = fh->jpg_settings.odd_even;
2389
2390 bparams->quality = fh->jpg_settings.jpg_comp.quality;
2391 bparams->APPn = fh->jpg_settings.jpg_comp.APPn;
2392 bparams->APP_len = fh->jpg_settings.jpg_comp.APP_len;
2393 memcpy(bparams->APP_data,
2394 fh->jpg_settings.jpg_comp.APP_data,
2395 sizeof(bparams->APP_data));
2396 bparams->COM_len = zr->jpg_settings.jpg_comp.COM_len;
2397 memcpy(bparams->COM_data,
2398 fh->jpg_settings.jpg_comp.COM_data,
2399 sizeof(bparams->COM_data));
2400 bparams->jpeg_markers =
2401 fh->jpg_settings.jpg_comp.jpeg_markers;
2402
2403 mutex_unlock(&zr->resource_lock);
2404
2405 bparams->VFIFO_FB = 0;
2406
2407 return 0;
2408 }
2409 break;
2410
2411 case BUZIOC_S_PARAMS:
2412 {
2413 struct zoran_params *bparams = arg;
2414 int res = 0;
2415
2416 dprintk(3, KERN_DEBUG "%s: BUZIOC_S_PARAMS\n", ZR_DEVNAME(zr));
2417
2418 settings.decimation = bparams->decimation;
2419 settings.HorDcm = bparams->HorDcm;
2420 settings.VerDcm = bparams->VerDcm;
2421 settings.TmpDcm = bparams->TmpDcm;
2422 settings.field_per_buff = bparams->field_per_buff;
2423 settings.img_x = bparams->img_x;
2424 settings.img_y = bparams->img_y;
2425 settings.img_width = bparams->img_width;
2426 settings.img_height = bparams->img_height;
2427 settings.odd_even = bparams->odd_even;
2428
2429 settings.jpg_comp.quality = bparams->quality;
2430 settings.jpg_comp.APPn = bparams->APPn;
2431 settings.jpg_comp.APP_len = bparams->APP_len;
2432 memcpy(settings.jpg_comp.APP_data, bparams->APP_data,
2433 sizeof(bparams->APP_data));
2434 settings.jpg_comp.COM_len = bparams->COM_len;
2435 memcpy(settings.jpg_comp.COM_data, bparams->COM_data,
2436 sizeof(bparams->COM_data));
2437 settings.jpg_comp.jpeg_markers = bparams->jpeg_markers;
2438
2439 mutex_lock(&zr->resource_lock);
2440
2441 if (zr->codec_mode != BUZ_MODE_IDLE) {
2442 dprintk(1,
2443 KERN_ERR
2444 "%s: BUZIOC_S_PARAMS called, but Buz in capture/playback mode\n",
2445 ZR_DEVNAME(zr));
2446 res = -EINVAL;
2447 goto sparams_unlock_and_return;
2448 }
2449
2450 /* Check the params first before overwriting our
2451 * nternal values */
2452 if (zoran_check_jpg_settings(zr, &settings)) {
2453 res = -EINVAL;
2454 goto sparams_unlock_and_return;
2455 }
2456
2457 fh->jpg_settings = settings;
2458 sparams_unlock_and_return:
2459 mutex_unlock(&zr->resource_lock);
2460
2461 return res;
2462 }
2463 break;
2464
2465 case BUZIOC_REQBUFS:
2466 {
2467 struct zoran_requestbuffers *breq = arg;
2468 int res = 0;
2469
2470 dprintk(3,
2471 KERN_DEBUG
2472 "%s: BUZIOC_REQBUFS - count=%lu, size=%lu\n",
2473 ZR_DEVNAME(zr), breq->count, breq->size);
2474
2475 /* Enforce reasonable lower and upper limits */
2476 if (breq->count < 4)
2477 breq->count = 4; /* Could be choosen smaller */
2478 if (breq->count > jpg_nbufs)
2479 breq->count = jpg_nbufs;
2480 breq->size = PAGE_ALIGN(breq->size);
2481 if (breq->size < 8192)
2482 breq->size = 8192; /* Arbitrary */
2483 /* breq->size is limited by 1 page for the stat_com
2484 * tables to a Maximum of 2 MB */
2485 if (breq->size > jpg_bufsize)
2486 breq->size = jpg_bufsize;
2487 if (fh->jpg_buffers.need_contiguous &&
2488 breq->size > MAX_KMALLOC_MEM)
2489 breq->size = MAX_KMALLOC_MEM;
2490
2491 mutex_lock(&zr->resource_lock);
2492
2493 if (fh->jpg_buffers.allocated || fh->v4l_buffers.allocated) {
2494 dprintk(1,
2495 KERN_ERR
2496 "%s: BUZIOC_REQBUFS - buffers allready allocated\n",
2497 ZR_DEVNAME(zr));
2498 res = -EBUSY;
2499 goto jpgreqbuf_unlock_and_return;
2500 }
2501
2502 fh->jpg_buffers.num_buffers = breq->count;
2503 fh->jpg_buffers.buffer_size = breq->size;
2504
2505 if (jpg_fbuffer_alloc(file)) {
2506 res = -ENOMEM;
2507 goto jpgreqbuf_unlock_and_return;
2508 }
2509
2510 /* The next mmap will map the MJPEG buffers - could
2511 * also be *_PLAY, but it doesn't matter here */
2512 fh->map_mode = ZORAN_MAP_MODE_JPG_REC;
2513 jpgreqbuf_unlock_and_return:
2514 mutex_unlock(&zr->resource_lock);
2515
2516 return res;
2517 }
2518 break;
2519
2520 case BUZIOC_QBUF_CAPT:
2521 {
2522 int *frame = arg, res;
2523
2524 dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_CAPT - frame=%d\n",
2525 ZR_DEVNAME(zr), *frame);
2526
2527 mutex_lock(&zr->resource_lock);
2528 res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_COMPRESS);
2529 mutex_unlock(&zr->resource_lock);
2530
2531 return res;
2532 }
2533 break;
2534
2535 case BUZIOC_QBUF_PLAY:
2536 {
2537 int *frame = arg, res;
2538
2539 dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_PLAY - frame=%d\n",
2540 ZR_DEVNAME(zr), *frame);
2541
2542 mutex_lock(&zr->resource_lock);
2543 res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_DECOMPRESS);
2544 mutex_unlock(&zr->resource_lock);
2545
2546 return res;
2547 }
2548 break;
2549
2550 case BUZIOC_SYNC:
2551 {
2552 struct zoran_sync *bsync = arg;
2553 int res;
2554
2555 dprintk(3, KERN_DEBUG "%s: BUZIOC_SYNC\n", ZR_DEVNAME(zr));
2556
2557 mutex_lock(&zr->resource_lock);
2558 res = jpg_sync(file, bsync);
2559 mutex_unlock(&zr->resource_lock);
2560
2561 return res;
2562 }
2563 break;
2564
2565 case BUZIOC_G_STATUS:
2566 {
2567 struct zoran_status *bstat = arg;
2568 int norm, input, status, res = 0;
2569
2570 dprintk(3, KERN_DEBUG "%s: BUZIOC_G_STATUS\n", ZR_DEVNAME(zr));
2571
2572 if (zr->codec_mode != BUZ_MODE_IDLE) {
2573 dprintk(1,
2574 KERN_ERR
2575 "%s: BUZIOC_G_STATUS called but Buz in capture/playback mode\n",
2576 ZR_DEVNAME(zr));
2577 return -EINVAL;
2578 }
2579
2580 input = zr->card.input[bstat->input].muxsel;
2581 norm = VIDEO_MODE_AUTO;
2582
2583 mutex_lock(&zr->resource_lock);
2584
2585 if (zr->codec_mode != BUZ_MODE_IDLE) {
2586 dprintk(1,
2587 KERN_ERR
2588 "%s: BUZIOC_G_STATUS called, but Buz in capture/playback mode\n",
2589 ZR_DEVNAME(zr));
2590 res = -EINVAL;
2591 goto gstat_unlock_and_return;
2592 }
2593
2594 decoder_command(zr, DECODER_SET_INPUT, &input);
2595 decoder_command(zr, DECODER_SET_NORM, &norm);
2596
2597 /* sleep 1 second */
2598 ssleep(1);
2599
2600 /* Get status of video decoder */
2601 decoder_command(zr, DECODER_GET_STATUS, &status);
2602
2603 /* restore previous input and norm */
2604 input = zr->card.input[zr->input].muxsel;
2605 decoder_command(zr, DECODER_SET_INPUT, &input);
2606 decoder_command(zr, DECODER_SET_NORM, &zr->norm);
2607 gstat_unlock_and_return:
2608 mutex_unlock(&zr->resource_lock);
2609
2610 if (!res) {
2611 bstat->signal =
2612 (status & DECODER_STATUS_GOOD) ? 1 : 0;
2613 if (status & DECODER_STATUS_NTSC)
2614 bstat->norm = VIDEO_MODE_NTSC;
2615 else if (status & DECODER_STATUS_SECAM)
2616 bstat->norm = VIDEO_MODE_SECAM;
2617 else
2618 bstat->norm = VIDEO_MODE_PAL;
2619
2620 bstat->color =
2621 (status & DECODER_STATUS_COLOR) ? 1 : 0;
2622 }
2623
2624 return res;
2625 }
2626 break;
2627
2628 #ifdef CONFIG_VIDEO_V4L2
2629
2630 /* The new video4linux2 capture interface - much nicer than video4linux1, since
2631 * it allows for integrating the JPEG capturing calls inside standard v4l2
2632 */
2633
2634 case VIDIOC_QUERYCAP:
2635 {
2636 struct v4l2_capability *cap = arg;
2637
2638 dprintk(3, KERN_DEBUG "%s: VIDIOC_QUERYCAP\n", ZR_DEVNAME(zr));
2639
2640 memset(cap, 0, sizeof(*cap));
2641 strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1);
2642 strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);
2643 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
2644 pci_name(zr->pci_dev));
2645 cap->version =
2646 KERNEL_VERSION(MAJOR_VERSION, MINOR_VERSION,
2647 RELEASE_VERSION);
2648 cap->capabilities = ZORAN_V4L2_VID_FLAGS;
2649
2650 return 0;
2651 }
2652 break;
2653
2654 case VIDIOC_ENUM_FMT:
2655 {
2656 struct v4l2_fmtdesc *fmt = arg;
2657 int index = fmt->index, num = -1, i, flag = 0, type =
2658 fmt->type;
2659
2660 dprintk(3, KERN_DEBUG "%s: VIDIOC_ENUM_FMT - index=%d\n",
2661 ZR_DEVNAME(zr), fmt->index);
2662
2663 switch (fmt->type) {
2664 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2665 flag = ZORAN_FORMAT_CAPTURE;
2666 break;
2667 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
2668 flag = ZORAN_FORMAT_PLAYBACK;
2669 break;
2670 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2671 flag = ZORAN_FORMAT_OVERLAY;
2672 break;
2673 default:
2674 dprintk(1,
2675 KERN_ERR
2676 "%s: VIDIOC_ENUM_FMT - unknown type %d\n",
2677 ZR_DEVNAME(zr), fmt->type);
2678 return -EINVAL;
2679 }
2680
2681 for (i = 0; i < NUM_FORMATS; i++) {
2682 if (zoran_formats[i].flags & flag)
2683 num++;
2684 if (num == fmt->index)
2685 break;
2686 }
2687 if (fmt->index < 0 /* late, but not too late */ ||
2688 i == NUM_FORMATS)
2689 return -EINVAL;
2690
2691 memset(fmt, 0, sizeof(*fmt));
2692 fmt->index = index;
2693 fmt->type = type;
2694 strncpy(fmt->description, zoran_formats[i].name, sizeof(fmt->description)-1);
2695 fmt->pixelformat = zoran_formats[i].fourcc;
2696 if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
2697 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
2698
2699 return 0;
2700 }
2701 break;
2702
2703 case VIDIOC_G_FMT:
2704 {
2705 struct v4l2_format *fmt = arg;
2706 int type = fmt->type;
2707
2708 dprintk(5, KERN_DEBUG "%s: VIDIOC_G_FMT\n", ZR_DEVNAME(zr));
2709
2710 memset(fmt, 0, sizeof(*fmt));
2711 fmt->type = type;
2712
2713 switch (fmt->type) {
2714 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2715
2716 mutex_lock(&zr->resource_lock);
2717
2718 fmt->fmt.win.w.left = fh->overlay_settings.x;
2719 fmt->fmt.win.w.top = fh->overlay_settings.y;
2720 fmt->fmt.win.w.width = fh->overlay_settings.width;
2721 fmt->fmt.win.w.height =
2722 fh->overlay_settings.height;
2723 if (fh->overlay_settings.width * 2 >
2724 BUZ_MAX_HEIGHT)
2725 fmt->fmt.win.field = V4L2_FIELD_INTERLACED;
2726 else
2727 fmt->fmt.win.field = V4L2_FIELD_TOP;
2728
2729 mutex_unlock(&zr->resource_lock);
2730
2731 break;
2732
2733 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2734 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
2735
2736 mutex_lock(&zr->resource_lock);
2737
2738 if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2739 fh->map_mode == ZORAN_MAP_MODE_RAW) {
2740
2741 fmt->fmt.pix.width =
2742 fh->v4l_settings.width;
2743 fmt->fmt.pix.height =
2744 fh->v4l_settings.height;
2745 fmt->fmt.pix.sizeimage =
2746 fh->v4l_settings.bytesperline *
2747 fh->v4l_settings.height;
2748 fmt->fmt.pix.pixelformat =
2749 fh->v4l_settings.format->fourcc;
2750 fmt->fmt.pix.colorspace =
2751 fh->v4l_settings.format->colorspace;
2752 fmt->fmt.pix.bytesperline = 0;
2753 if (BUZ_MAX_HEIGHT <
2754 (fh->v4l_settings.height * 2))
2755 fmt->fmt.pix.field =
2756 V4L2_FIELD_INTERLACED;
2757 else
2758 fmt->fmt.pix.field =
2759 V4L2_FIELD_TOP;
2760
2761 } else {
2762
2763 fmt->fmt.pix.width =
2764 fh->jpg_settings.img_width /
2765 fh->jpg_settings.HorDcm;
2766 fmt->fmt.pix.height =
2767 fh->jpg_settings.img_height /
2768 (fh->jpg_settings.VerDcm *
2769 fh->jpg_settings.TmpDcm);
2770 fmt->fmt.pix.sizeimage =
2771 zoran_v4l2_calc_bufsize(&fh->
2772 jpg_settings);
2773 fmt->fmt.pix.pixelformat =
2774 V4L2_PIX_FMT_MJPEG;
2775 if (fh->jpg_settings.TmpDcm == 1)
2776 fmt->fmt.pix.field =
2777 (fh->jpg_settings.
2778 odd_even ? V4L2_FIELD_SEQ_BT :
2779 V4L2_FIELD_SEQ_BT);
2780 else
2781 fmt->fmt.pix.field =
2782 (fh->jpg_settings.
2783 odd_even ? V4L2_FIELD_TOP :
2784 V4L2_FIELD_BOTTOM);
2785
2786 fmt->fmt.pix.bytesperline = 0;
2787 fmt->fmt.pix.colorspace =
2788 V4L2_COLORSPACE_SMPTE170M;
2789 }
2790
2791 mutex_unlock(&zr->resource_lock);
2792
2793 break;
2794
2795 default:
2796 dprintk(1,
2797 KERN_ERR
2798 "%s: VIDIOC_G_FMT - unsupported type %d\n",
2799 ZR_DEVNAME(zr), fmt->type);
2800 return -EINVAL;
2801 }
2802 return 0;
2803 }
2804 break;
2805
2806 case VIDIOC_S_FMT:
2807 {
2808 struct v4l2_format *fmt = arg;
2809 int i, res = 0;
2810 __u32 printformat;
2811
2812 dprintk(3, KERN_DEBUG "%s: VIDIOC_S_FMT - type=%d, ",
2813 ZR_DEVNAME(zr), fmt->type);
2814
2815 switch (fmt->type) {
2816 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2817
2818 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
2819 fmt->fmt.win.w.left, fmt->fmt.win.w.top,
2820 fmt->fmt.win.w.width,
2821 fmt->fmt.win.w.height,
2822 fmt->fmt.win.clipcount,
2823 fmt->fmt.win.bitmap);
2824 mutex_lock(&zr->resource_lock);
2825 res =
2826 setup_window(file, fmt->fmt.win.w.left,
2827 fmt->fmt.win.w.top,
2828 fmt->fmt.win.w.width,
2829 fmt->fmt.win.w.height,
2830 (struct video_clip __user *)
2831 fmt->fmt.win.clips,
2832 fmt->fmt.win.clipcount,
2833 fmt->fmt.win.bitmap);
2834 mutex_unlock(&zr->resource_lock);
2835 return res;
2836 break;
2837
2838 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2839 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
2840
2841 printformat =
2842 __cpu_to_le32(fmt->fmt.pix.pixelformat);
2843 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
2844 fmt->fmt.pix.width, fmt->fmt.pix.height,
2845 fmt->fmt.pix.pixelformat,
2846 (char *) &printformat);
2847
2848 if (fmt->fmt.pix.bytesperline > 0) {
2849 dprintk(5,
2850 KERN_ERR "%s: bpl not supported\n",
2851 ZR_DEVNAME(zr));
2852 return -EINVAL;
2853 }
2854
2855 /* we can be requested to do JPEG/raw playback/capture */
2856 if (!
2857 (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2858 (fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2859 fmt->fmt.pix.pixelformat ==
2860 V4L2_PIX_FMT_MJPEG))) {
2861 dprintk(1,
2862 KERN_ERR
2863 "%s: VIDIOC_S_FMT - unknown type %d/0x%x(%4.4s) combination\n",
2864 ZR_DEVNAME(zr), fmt->type,
2865 fmt->fmt.pix.pixelformat,
2866 (char *) &printformat);
2867 return -EINVAL;
2868 }
2869
2870 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) {
2871 mutex_lock(&zr->resource_lock);
2872
2873 settings = fh->jpg_settings;
2874
2875 if (fh->v4l_buffers.allocated ||
2876 fh->jpg_buffers.allocated) {
2877 dprintk(1,
2878 KERN_ERR
2879 "%s: VIDIOC_S_FMT - cannot change capture mode\n",
2880 ZR_DEVNAME(zr));
2881 res = -EBUSY;
2882 goto sfmtjpg_unlock_and_return;
2883 }
2884
2885 /* we actually need to set 'real' parameters now */
2886 if ((fmt->fmt.pix.height * 2) >
2887 BUZ_MAX_HEIGHT)
2888 settings.TmpDcm = 1;
2889 else
2890 settings.TmpDcm = 2;
2891 settings.decimation = 0;
2892 if (fmt->fmt.pix.height <=
2893 fh->jpg_settings.img_height / 2)
2894 settings.VerDcm = 2;
2895 else
2896 settings.VerDcm = 1;
2897 if (fmt->fmt.pix.width <=
2898 fh->jpg_settings.img_width / 4)
2899 settings.HorDcm = 4;
2900 else if (fmt->fmt.pix.width <=
2901 fh->jpg_settings.img_width / 2)
2902 settings.HorDcm = 2;
2903 else
2904 settings.HorDcm = 1;
2905 if (settings.TmpDcm == 1)
2906 settings.field_per_buff = 2;
2907 else
2908 settings.field_per_buff = 1;
2909
2910 /* check */
2911 if ((res =
2912 zoran_check_jpg_settings(zr,
2913 &settings)))
2914 goto sfmtjpg_unlock_and_return;
2915
2916 /* it's ok, so set them */
2917 fh->jpg_settings = settings;
2918
2919 /* tell the user what we actually did */
2920 fmt->fmt.pix.width =
2921 settings.img_width / settings.HorDcm;
2922 fmt->fmt.pix.height =
2923 settings.img_height * 2 /
2924 (settings.TmpDcm * settings.VerDcm);
2925 if (settings.TmpDcm == 1)
2926 fmt->fmt.pix.field =
2927 (fh->jpg_settings.
2928 odd_even ? V4L2_FIELD_SEQ_TB :
2929 V4L2_FIELD_SEQ_BT);
2930 else
2931 fmt->fmt.pix.field =
2932 (fh->jpg_settings.
2933 odd_even ? V4L2_FIELD_TOP :
2934 V4L2_FIELD_BOTTOM);
2935 fh->jpg_buffers.buffer_size =
2936 zoran_v4l2_calc_bufsize(&fh->
2937 jpg_settings);
2938 fmt->fmt.pix.sizeimage =
2939 fh->jpg_buffers.buffer_size;
2940
2941 /* we hereby abuse this variable to show that
2942 * we're gonna do mjpeg capture */
2943 fh->map_mode =
2944 (fmt->type ==
2945 V4L2_BUF_TYPE_VIDEO_CAPTURE) ?
2946 ZORAN_MAP_MODE_JPG_REC :
2947 ZORAN_MAP_MODE_JPG_PLAY;
2948 sfmtjpg_unlock_and_return:
2949 mutex_unlock(&zr->resource_lock);
2950 } else {
2951 for (i = 0; i < NUM_FORMATS; i++)
2952 if (fmt->fmt.pix.pixelformat ==
2953 zoran_formats[i].fourcc)
2954 break;
2955 if (i == NUM_FORMATS) {
2956 dprintk(1,
2957 KERN_ERR
2958 "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x (%4.4s)\n",
2959 ZR_DEVNAME(zr),
2960 fmt->fmt.pix.pixelformat,
2961 (char *) &printformat);
2962 return -EINVAL;
2963 }
2964 mutex_lock(&zr->resource_lock);
2965 if (fh->jpg_buffers.allocated ||
2966 (fh->v4l_buffers.allocated &&
2967 fh->v4l_buffers.active !=
2968 ZORAN_FREE)) {
2969 dprintk(1,
2970 KERN_ERR
2971 "%s: VIDIOC_S_FMT - cannot change capture mode\n",
2972 ZR_DEVNAME(zr));
2973 res = -EBUSY;
2974 goto sfmtv4l_unlock_and_return;
2975 }
2976 if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
2977 fmt->fmt.pix.height =
2978 BUZ_MAX_HEIGHT;
2979 if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
2980 fmt->fmt.pix.width = BUZ_MAX_WIDTH;
2981
2982 if ((res =
2983 zoran_v4l_set_format(file,
2984 fmt->fmt.pix.
2985 width,
2986 fmt->fmt.pix.
2987 height,
2988 &zoran_formats
2989 [i])))
2990 goto sfmtv4l_unlock_and_return;
2991
2992 /* tell the user the
2993 * results/missing stuff */
2994 fmt->fmt.pix.sizeimage =
2995 fh->v4l_settings.height *
2996 fh->v4l_settings.bytesperline;
2997 if (BUZ_MAX_HEIGHT <
2998 (fh->v4l_settings.height * 2))
2999 fmt->fmt.pix.field =
3000 V4L2_FIELD_INTERLACED;
3001 else
3002 fmt->fmt.pix.field =
3003 V4L2_FIELD_TOP;
3004
3005 fh->map_mode = ZORAN_MAP_MODE_RAW;
3006 sfmtv4l_unlock_and_return:
3007 mutex_unlock(&zr->resource_lock);
3008 }
3009
3010 break;
3011
3012 default:
3013 dprintk(3, "unsupported\n");
3014 dprintk(1,
3015 KERN_ERR
3016 "%s: VIDIOC_S_FMT - unsupported type %d\n",
3017 ZR_DEVNAME(zr), fmt->type);
3018 return -EINVAL;
3019 }
3020
3021 return res;
3022 }
3023 break;
3024
3025 case VIDIOC_G_FBUF:
3026 {
3027 struct v4l2_framebuffer *fb = arg;
3028
3029 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_FBUF\n", ZR_DEVNAME(zr));
3030
3031 memset(fb, 0, sizeof(*fb));
3032 mutex_lock(&zr->resource_lock);
3033 fb->base = zr->buffer.base;
3034 fb->fmt.width = zr->buffer.width;
3035 fb->fmt.height = zr->buffer.height;
3036 if (zr->overlay_settings.format) {
3037 fb->fmt.pixelformat =
3038 fh->overlay_settings.format->fourcc;
3039 }
3040 fb->fmt.bytesperline = zr->buffer.bytesperline;
3041 mutex_unlock(&zr->resource_lock);
3042 fb->fmt.colorspace = V4L2_COLORSPACE_SRGB;
3043 fb->fmt.field = V4L2_FIELD_INTERLACED;
3044 fb->flags = V4L2_FBUF_FLAG_OVERLAY;
3045 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
3046
3047 return 0;
3048 }
3049 break;
3050
3051 case VIDIOC_S_FBUF:
3052 {
3053 int i, res = 0;
3054 struct v4l2_framebuffer *fb = arg;
3055 __u32 printformat = __cpu_to_le32(fb->fmt.pixelformat);
3056
3057 dprintk(3,
3058 KERN_DEBUG
3059 "%s: VIDIOC_S_FBUF - base=0x%p, size=%dx%d, bpl=%d, fmt=0x%x (%4.4s)\n",
3060 ZR_DEVNAME(zr), fb->base, fb->fmt.width, fb->fmt.height,
3061 fb->fmt.bytesperline, fb->fmt.pixelformat,
3062 (char *) &printformat);
3063
3064 for (i = 0; i < NUM_FORMATS; i++)
3065 if (zoran_formats[i].fourcc == fb->fmt.pixelformat)
3066 break;
3067 if (i == NUM_FORMATS) {
3068 dprintk(1,
3069 KERN_ERR
3070 "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
3071 ZR_DEVNAME(zr), fb->fmt.pixelformat,
3072 (char *) &printformat);
3073 return -EINVAL;
3074 }
3075
3076 mutex_lock(&zr->resource_lock);
3077 res =
3078 setup_fbuffer(file, fb->base, &zoran_formats[i],
3079 fb->fmt.width, fb->fmt.height,
3080 fb->fmt.bytesperline);
3081 mutex_unlock(&zr->resource_lock);
3082
3083 return res;
3084 }
3085 break;
3086
3087 case VIDIOC_OVERLAY:
3088 {
3089 int *on = arg, res;
3090
3091 dprintk(3, KERN_DEBUG "%s: VIDIOC_PREVIEW - on=%d\n",
3092 ZR_DEVNAME(zr), *on);
3093
3094 mutex_lock(&zr->resource_lock);
3095 res = setup_overlay(file, *on);
3096 mutex_unlock(&zr->resource_lock);
3097
3098 return res;
3099 }
3100 break;
3101
3102 case VIDIOC_REQBUFS:
3103 {
3104 struct v4l2_requestbuffers *req = arg;
3105 int res = 0;
3106
3107 dprintk(3, KERN_DEBUG "%s: VIDIOC_REQBUFS - type=%d\n",
3108 ZR_DEVNAME(zr), req->type);
3109
3110 if (req->memory != V4L2_MEMORY_MMAP) {
3111 dprintk(1,
3112 KERN_ERR
3113 "%s: only MEMORY_MMAP capture is supported, not %d\n",
3114 ZR_DEVNAME(zr), req->memory);
3115 return -EINVAL;
3116 }
3117
3118 mutex_lock(&zr->resource_lock);
3119
3120 if (fh->v4l_buffers.allocated || fh->jpg_buffers.allocated) {
3121 dprintk(1,
3122 KERN_ERR
3123 "%s: VIDIOC_REQBUFS - buffers allready allocated\n",
3124 ZR_DEVNAME(zr));
3125 res = -EBUSY;
3126 goto v4l2reqbuf_unlock_and_return;
3127 }
3128
3129 if (fh->map_mode == ZORAN_MAP_MODE_RAW &&
3130 req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
3131
3132 /* control user input */
3133 if (req->count < 2)
3134 req->count = 2;
3135 if (req->count > v4l_nbufs)
3136 req->count = v4l_nbufs;
3137 fh->v4l_buffers.num_buffers = req->count;
3138
3139 if (v4l_fbuffer_alloc(file)) {
3140 res = -ENOMEM;
3141 goto v4l2reqbuf_unlock_and_return;
3142 }
3143
3144 /* The next mmap will map the V4L buffers */
3145 fh->map_mode = ZORAN_MAP_MODE_RAW;
3146
3147 } else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC ||
3148 fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
3149
3150 /* we need to calculate size ourselves now */
3151 if (req->count < 4)
3152 req->count = 4;
3153 if (req->count > jpg_nbufs)
3154 req->count = jpg_nbufs;
3155 fh->jpg_buffers.num_buffers = req->count;
3156 fh->jpg_buffers.buffer_size =
3157 zoran_v4l2_calc_bufsize(&fh->jpg_settings);
3158
3159 if (jpg_fbuffer_alloc(file)) {
3160 res = -ENOMEM;
3161 goto v4l2reqbuf_unlock_and_return;
3162 }
3163
3164 /* The next mmap will map the MJPEG buffers */
3165 if (req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
3166 fh->map_mode = ZORAN_MAP_MODE_JPG_REC;
3167 else
3168 fh->map_mode = ZORAN_MAP_MODE_JPG_PLAY;
3169
3170 } else {
3171 dprintk(1,
3172 KERN_ERR
3173 "%s: VIDIOC_REQBUFS - unknown type %d\n",
3174 ZR_DEVNAME(zr), req->type);
3175 res = -EINVAL;
3176 goto v4l2reqbuf_unlock_and_return;
3177 }
3178 v4l2reqbuf_unlock_and_return:
3179 mutex_unlock(&zr->resource_lock);
3180
3181 return 0;
3182 }
3183 break;
3184
3185 case VIDIOC_QUERYBUF:
3186 {
3187 struct v4l2_buffer *buf = arg;
3188 __u32 type = buf->type;
3189 int index = buf->index, res;
3190
3191 dprintk(3,
3192 KERN_DEBUG
3193 "%s: VIDIOC_QUERYBUF - index=%d, type=%d\n",
3194 ZR_DEVNAME(zr), buf->index, buf->type);
3195
3196 memset(buf, 0, sizeof(*buf));
3197 buf->type = type;
3198 buf->index = index;
3199
3200 mutex_lock(&zr->resource_lock);
3201 res = zoran_v4l2_buffer_status(file, buf, buf->index);
3202 mutex_unlock(&zr->resource_lock);
3203
3204 return res;
3205 }
3206 break;
3207
3208 case VIDIOC_QBUF:
3209 {
3210 struct v4l2_buffer *buf = arg;
3211 int res = 0, codec_mode, buf_type;
3212
3213 dprintk(3,
3214 KERN_DEBUG "%s: VIDIOC_QBUF - type=%d, index=%d\n",
3215 ZR_DEVNAME(zr), buf->type, buf->index);
3216
3217 mutex_lock(&zr->resource_lock);
3218
3219 switch (fh->map_mode) {
3220 case ZORAN_MAP_MODE_RAW:
3221 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
3222 dprintk(1,
3223 KERN_ERR
3224 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
3225 ZR_DEVNAME(zr), buf->type, fh->map_mode);
3226 res = -EINVAL;
3227 goto qbuf_unlock_and_return;
3228 }
3229
3230 res = zoran_v4l_queue_frame(file, buf->index);
3231 if (res)
3232 goto qbuf_unlock_and_return;
3233 if (!zr->v4l_memgrab_active &&
3234 fh->v4l_buffers.active == ZORAN_LOCKED)
3235 zr36057_set_memgrab(zr, 1);
3236 break;
3237
3238 case ZORAN_MAP_MODE_JPG_REC:
3239 case ZORAN_MAP_MODE_JPG_PLAY:
3240 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
3241 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
3242 codec_mode = BUZ_MODE_MOTION_DECOMPRESS;
3243 } else {
3244 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3245 codec_mode = BUZ_MODE_MOTION_COMPRESS;
3246 }
3247
3248 if (buf->type != buf_type) {
3249 dprintk(1,
3250 KERN_ERR
3251 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
3252 ZR_DEVNAME(zr), buf->type, fh->map_mode);
3253 res = -EINVAL;
3254 goto qbuf_unlock_and_return;
3255 }
3256
3257 res =
3258 zoran_jpg_queue_frame(file, buf->index,
3259 codec_mode);
3260 if (res != 0)
3261 goto qbuf_unlock_and_return;
3262 if (zr->codec_mode == BUZ_MODE_IDLE &&
3263 fh->jpg_buffers.active == ZORAN_LOCKED) {
3264 zr36057_enable_jpg(zr, codec_mode);
3265 }
3266 break;
3267
3268 default:
3269 dprintk(1,
3270 KERN_ERR
3271 "%s: VIDIOC_QBUF - unsupported type %d\n",
3272 ZR_DEVNAME(zr), buf->type);
3273 res = -EINVAL;
3274 goto qbuf_unlock_and_return;
3275 }
3276 qbuf_unlock_and_return:
3277 mutex_unlock(&zr->resource_lock);
3278
3279 return res;
3280 }
3281 break;
3282
3283 case VIDIOC_DQBUF:
3284 {
3285 struct v4l2_buffer *buf = arg;
3286 int res = 0, buf_type, num = -1; /* compiler borks here (?) */
3287
3288 dprintk(3, KERN_DEBUG "%s: VIDIOC_DQBUF - type=%d\n",
3289 ZR_DEVNAME(zr), buf->type);
3290
3291 mutex_lock(&zr->resource_lock);
3292
3293 switch (fh->map_mode) {
3294 case ZORAN_MAP_MODE_RAW:
3295 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
3296 dprintk(1,
3297 KERN_ERR
3298 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
3299 ZR_DEVNAME(zr), buf->type, fh->map_mode);
3300 res = -EINVAL;
3301 goto dqbuf_unlock_and_return;
3302 }
3303
3304 num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
3305 if (file->f_flags & O_NONBLOCK &&
3306 zr->v4l_buffers.buffer[num].state !=
3307 BUZ_STATE_DONE) {
3308 res = -EAGAIN;
3309 goto dqbuf_unlock_and_return;
3310 }
3311 res = v4l_sync(file, num);
3312 if (res)
3313 goto dqbuf_unlock_and_return;
3314 else
3315 zr->v4l_sync_tail++;
3316 res = zoran_v4l2_buffer_status(file, buf, num);
3317 break;
3318
3319 case ZORAN_MAP_MODE_JPG_REC:
3320 case ZORAN_MAP_MODE_JPG_PLAY:
3321 {
3322 struct zoran_sync bs;
3323
3324 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY)
3325 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
3326 else
3327 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3328
3329 if (buf->type != buf_type) {
3330 dprintk(1,
3331 KERN_ERR
3332 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
3333 ZR_DEVNAME(zr), buf->type, fh->map_mode);
3334 res = -EINVAL;
3335 goto dqbuf_unlock_and_return;
3336 }
3337
3338 num =
3339 zr->jpg_pend[zr->
3340 jpg_que_tail & BUZ_MASK_FRAME];
3341
3342 if (file->f_flags & O_NONBLOCK &&
3343 zr->jpg_buffers.buffer[num].state !=
3344 BUZ_STATE_DONE) {
3345 res = -EAGAIN;
3346 goto dqbuf_unlock_and_return;
3347 }
3348 res = jpg_sync(file, &bs);
3349 if (res)
3350 goto dqbuf_unlock_and_return;
3351 res =
3352 zoran_v4l2_buffer_status(file, buf, bs.frame);
3353 break;
3354 }
3355
3356 default:
3357 dprintk(1,
3358 KERN_ERR
3359 "%s: VIDIOC_DQBUF - unsupported type %d\n",
3360 ZR_DEVNAME(zr), buf->type);
3361 res = -EINVAL;
3362 goto dqbuf_unlock_and_return;
3363 }
3364 dqbuf_unlock_and_return:
3365 mutex_unlock(&zr->resource_lock);
3366
3367 return res;
3368 }
3369 break;
3370
3371 case VIDIOC_STREAMON:
3372 {
3373 int res = 0;
3374
3375 dprintk(3, KERN_DEBUG "%s: VIDIOC_STREAMON\n", ZR_DEVNAME(zr));
3376
3377 mutex_lock(&zr->resource_lock);
3378
3379 switch (fh->map_mode) {
3380 case ZORAN_MAP_MODE_RAW: /* raw capture */
3381 if (zr->v4l_buffers.active != ZORAN_ACTIVE ||
3382 fh->v4l_buffers.active != ZORAN_ACTIVE) {
3383 res = -EBUSY;
3384 goto strmon_unlock_and_return;
3385 }
3386
3387 zr->v4l_buffers.active = fh->v4l_buffers.active =
3388 ZORAN_LOCKED;
3389 zr->v4l_settings = fh->v4l_settings;
3390
3391 zr->v4l_sync_tail = zr->v4l_pend_tail;
3392 if (!zr->v4l_memgrab_active &&
3393 zr->v4l_pend_head != zr->v4l_pend_tail) {
3394 zr36057_set_memgrab(zr, 1);
3395 }
3396 break;
3397
3398 case ZORAN_MAP_MODE_JPG_REC:
3399 case ZORAN_MAP_MODE_JPG_PLAY:
3400 /* what is the codec mode right now? */
3401 if (zr->jpg_buffers.active != ZORAN_ACTIVE ||
3402 fh->jpg_buffers.active != ZORAN_ACTIVE) {
3403 res = -EBUSY;
3404 goto strmon_unlock_and_return;
3405 }
3406
3407 zr->jpg_buffers.active = fh->jpg_buffers.active =
3408 ZORAN_LOCKED;
3409
3410 if (zr->jpg_que_head != zr->jpg_que_tail) {
3411 /* Start the jpeg codec when the first frame is queued */
3412 jpeg_start(zr);
3413 }
3414
3415 break;
3416 default:
3417 dprintk(1,
3418 KERN_ERR
3419 "%s: VIDIOC_STREAMON - invalid map mode %d\n",
3420 ZR_DEVNAME(zr), fh->map_mode);
3421 res = -EINVAL;
3422 goto strmon_unlock_and_return;
3423 }
3424 strmon_unlock_and_return:
3425 mutex_unlock(&zr->resource_lock);
3426
3427 return res;
3428 }
3429 break;
3430
3431 case VIDIOC_STREAMOFF:
3432 {
3433 int i, res = 0;
3434
3435 dprintk(3, KERN_DEBUG "%s: VIDIOC_STREAMOFF\n", ZR_DEVNAME(zr));
3436
3437 mutex_lock(&zr->resource_lock);
3438
3439 switch (fh->map_mode) {
3440 case ZORAN_MAP_MODE_RAW: /* raw capture */
3441 if (fh->v4l_buffers.active == ZORAN_FREE &&
3442 zr->v4l_buffers.active != ZORAN_FREE) {
3443 res = -EPERM; /* stay off other's settings! */
3444 goto strmoff_unlock_and_return;
3445 }
3446 if (zr->v4l_buffers.active == ZORAN_FREE)
3447 goto strmoff_unlock_and_return;
3448
3449 /* unload capture */
3450 if (zr->v4l_memgrab_active) {
3451 long flags;
3452
3453 spin_lock_irqsave(&zr->spinlock, flags);
3454 zr36057_set_memgrab(zr, 0);
3455 spin_unlock_irqrestore(&zr->spinlock, flags);
3456 }
3457
3458 for (i = 0; i < fh->v4l_buffers.num_buffers; i++)
3459 zr->v4l_buffers.buffer[i].state =
3460 BUZ_STATE_USER;
3461 fh->v4l_buffers = zr->v4l_buffers;
3462
3463 zr->v4l_buffers.active = fh->v4l_buffers.active =
3464 ZORAN_FREE;
3465
3466 zr->v4l_grab_seq = 0;
3467 zr->v4l_pend_head = zr->v4l_pend_tail = 0;
3468 zr->v4l_sync_tail = 0;
3469
3470 break;
3471
3472 case ZORAN_MAP_MODE_JPG_REC:
3473 case ZORAN_MAP_MODE_JPG_PLAY:
3474 if (fh->jpg_buffers.active == ZORAN_FREE &&
3475 zr->jpg_buffers.active != ZORAN_FREE) {
3476 res = -EPERM; /* stay off other's settings! */
3477 goto strmoff_unlock_and_return;
3478 }
3479 if (zr->jpg_buffers.active == ZORAN_FREE)
3480 goto strmoff_unlock_and_return;
3481
3482 res =
3483 jpg_qbuf(file, -1,
3484 (fh->map_mode ==
3485 ZORAN_MAP_MODE_JPG_REC) ?
3486 BUZ_MODE_MOTION_COMPRESS :
3487 BUZ_MODE_MOTION_DECOMPRESS);
3488 if (res)
3489 goto strmoff_unlock_and_return;
3490 break;
3491 default:
3492 dprintk(1,
3493 KERN_ERR
3494 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
3495 ZR_DEVNAME(zr), fh->map_mode);
3496 res = -EINVAL;
3497 goto strmoff_unlock_and_return;
3498 }
3499 strmoff_unlock_and_return:
3500 mutex_unlock(&zr->resource_lock);
3501
3502 return res;
3503 }
3504 break;
3505
3506 case VIDIOC_QUERYCTRL:
3507 {
3508 struct v4l2_queryctrl *ctrl = arg;
3509
3510 dprintk(3, KERN_DEBUG "%s: VIDIOC_QUERYCTRL - id=%d\n",
3511 ZR_DEVNAME(zr), ctrl->id);
3512
3513 /* we only support hue/saturation/contrast/brightness */
3514 if (ctrl->id < V4L2_CID_BRIGHTNESS ||
3515 ctrl->id > V4L2_CID_HUE)
3516 return -EINVAL;
3517 else {
3518 int id = ctrl->id;
3519 memset(ctrl, 0, sizeof(*ctrl));
3520 ctrl->id = id;
3521 }
3522
3523 switch (ctrl->id) {
3524 case V4L2_CID_BRIGHTNESS:
3525 strncpy(ctrl->name, "Brightness", sizeof(ctrl->name)-1);
3526 break;
3527 case V4L2_CID_CONTRAST:
3528 strncpy(ctrl->name, "Contrast", sizeof(ctrl->name)-1);
3529 break;
3530 case V4L2_CID_SATURATION:
3531 strncpy(ctrl->name, "Saturation", sizeof(ctrl->name)-1);
3532 break;
3533 case V4L2_CID_HUE:
3534 strncpy(ctrl->name, "Hue", sizeof(ctrl->name)-1);
3535 break;
3536 }
3537
3538 ctrl->minimum = 0;
3539 ctrl->maximum = 65535;
3540 ctrl->step = 1;
3541 ctrl->default_value = 32768;
3542 ctrl->type = V4L2_CTRL_TYPE_INTEGER;
3543
3544 return 0;
3545 }
3546 break;
3547
3548 case VIDIOC_G_CTRL:
3549 {
3550 struct v4l2_control *ctrl = arg;
3551
3552 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_CTRL - id=%d\n",
3553 ZR_DEVNAME(zr), ctrl->id);
3554
3555 /* we only support hue/saturation/contrast/brightness */
3556 if (ctrl->id < V4L2_CID_BRIGHTNESS ||
3557 ctrl->id > V4L2_CID_HUE)
3558 return -EINVAL;
3559
3560 mutex_lock(&zr->resource_lock);
3561 switch (ctrl->id) {
3562 case V4L2_CID_BRIGHTNESS:
3563 ctrl->value = zr->brightness;
3564 break;
3565 case V4L2_CID_CONTRAST:
3566 ctrl->value = zr->contrast;
3567 break;
3568 case V4L2_CID_SATURATION:
3569 ctrl->value = zr->saturation;
3570 break;
3571 case V4L2_CID_HUE:
3572 ctrl->value = zr->hue;
3573 break;
3574 }
3575 mutex_unlock(&zr->resource_lock);
3576
3577 return 0;
3578 }
3579 break;
3580
3581 case VIDIOC_S_CTRL:
3582 {
3583 struct v4l2_control *ctrl = arg;
3584 struct video_picture pict;
3585
3586 dprintk(3, KERN_DEBUG "%s: VIDIOC_S_CTRL - id=%d\n",
3587 ZR_DEVNAME(zr), ctrl->id);
3588
3589 /* we only support hue/saturation/contrast/brightness */
3590 if (ctrl->id < V4L2_CID_BRIGHTNESS ||
3591 ctrl->id > V4L2_CID_HUE)
3592 return -EINVAL;
3593
3594 if (ctrl->value < 0 || ctrl->value > 65535) {
3595 dprintk(1,
3596 KERN_ERR
3597 "%s: VIDIOC_S_CTRL - invalid value %d for id=%d\n",
3598 ZR_DEVNAME(zr), ctrl->value, ctrl->id);
3599 return -EINVAL;
3600 }
3601
3602 mutex_lock(&zr->resource_lock);
3603 switch (ctrl->id) {
3604 case V4L2_CID_BRIGHTNESS:
3605 zr->brightness = ctrl->value;
3606 break;
3607 case V4L2_CID_CONTRAST:
3608 zr->contrast = ctrl->value;
3609 break;
3610 case V4L2_CID_SATURATION:
3611 zr->saturation = ctrl->value;
3612 break;
3613 case V4L2_CID_HUE:
3614 zr->hue = ctrl->value;
3615 break;
3616 }
3617 pict.brightness = zr->brightness;
3618 pict.contrast = zr->contrast;
3619 pict.colour = zr->saturation;
3620 pict.hue = zr->hue;
3621
3622 decoder_command(zr, DECODER_SET_PICTURE, &pict);
3623
3624 mutex_unlock(&zr->resource_lock);
3625
3626 return 0;
3627 }
3628 break;
3629
3630 case VIDIOC_ENUMSTD:
3631 {
3632 struct v4l2_standard *std = arg;
3633
3634 dprintk(3, KERN_DEBUG "%s: VIDIOC_ENUMSTD - index=%d\n",
3635 ZR_DEVNAME(zr), std->index);
3636
3637 if (std->index < 0 || std->index >= (zr->card.norms + 1))
3638 return -EINVAL;
3639 else {
3640 int id = std->index;
3641 memset(std, 0, sizeof(*std));
3642 std->index = id;
3643 }
3644
3645 if (std->index == zr->card.norms) {
3646 /* if we have autodetect, ... */
3647 struct video_decoder_capability caps;
3648 decoder_command(zr, DECODER_GET_CAPABILITIES,
3649 &caps);
3650 if (caps.flags & VIDEO_DECODER_AUTO) {
3651 std->id = V4L2_STD_ALL;
3652 strncpy(std->name, "Autodetect", sizeof(std->name)-1);
3653 return 0;
3654 } else
3655 return -EINVAL;
3656 }
3657 switch (std->index) {
3658 case 0:
3659 std->id = V4L2_STD_PAL;
3660 strncpy(std->name, "PAL", sizeof(std->name)-1);
3661 std->frameperiod.numerator = 1;
3662 std->frameperiod.denominator = 25;
3663 std->framelines = zr->card.tvn[0]->Ht;
3664 break;
3665 case 1:
3666 std->id = V4L2_STD_NTSC;
3667 strncpy(std->name, "NTSC", sizeof(std->name)-1);
3668 std->frameperiod.numerator = 1001;
3669 std->frameperiod.denominator = 30000;
3670 std->framelines = zr->card.tvn[1]->Ht;
3671 break;
3672 case 2:
3673 std->id = V4L2_STD_SECAM;
3674 strncpy(std->name, "SECAM", sizeof(std->name)-1);
3675 std->frameperiod.numerator = 1;
3676 std->frameperiod.denominator = 25;
3677 std->framelines = zr->card.tvn[2]->Ht;
3678 break;
3679 }
3680
3681 return 0;
3682 }
3683 break;
3684
3685 case VIDIOC_G_STD:
3686 {
3687 v4l2_std_id *std = arg;
3688 int norm;
3689
3690 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_STD\n", ZR_DEVNAME(zr));
3691
3692 mutex_lock(&zr->resource_lock);
3693 norm = zr->norm;
3694 mutex_unlock(&zr->resource_lock);
3695
3696 switch (norm) {
3697 case VIDEO_MODE_PAL:
3698 *std = V4L2_STD_PAL;
3699 break;
3700 case VIDEO_MODE_NTSC:
3701 *std = V4L2_STD_NTSC;
3702 break;
3703 case VIDEO_MODE_SECAM:
3704 *std = V4L2_STD_SECAM;
3705 break;
3706 }
3707
3708 return 0;
3709 }
3710 break;
3711
3712 case VIDIOC_S_STD:
3713 {
3714 int norm = -1, res = 0;
3715 v4l2_std_id *std = arg;
3716
3717 dprintk(3, KERN_DEBUG "%s: VIDIOC_S_STD - norm=0x%llx\n",
3718 ZR_DEVNAME(zr), (unsigned long long)*std);
3719
3720 if ((*std & V4L2_STD_PAL) && !(*std & ~V4L2_STD_PAL))
3721 norm = VIDEO_MODE_PAL;
3722 else if ((*std & V4L2_STD_NTSC) && !(*std & ~V4L2_STD_NTSC))
3723 norm = VIDEO_MODE_NTSC;
3724 else if ((*std & V4L2_STD_SECAM) && !(*std & ~V4L2_STD_SECAM))
3725 norm = VIDEO_MODE_SECAM;
3726 else if (*std == V4L2_STD_ALL)
3727 norm = VIDEO_MODE_AUTO;
3728 else {
3729 dprintk(1,
3730 KERN_ERR
3731 "%s: VIDIOC_S_STD - invalid norm 0x%llx\n",
3732 ZR_DEVNAME(zr), (unsigned long long)*std);
3733 return -EINVAL;
3734 }
3735
3736 mutex_lock(&zr->resource_lock);
3737 if ((res = zoran_set_norm(zr, norm)))
3738 goto sstd_unlock_and_return;
3739
3740 res = wait_grab_pending(zr);
3741 sstd_unlock_and_return:
3742 mutex_unlock(&zr->resource_lock);
3743 return res;
3744 }
3745 break;
3746
3747 case VIDIOC_ENUMINPUT:
3748 {
3749 struct v4l2_input *inp = arg;
3750 int status;
3751
3752 dprintk(3, KERN_DEBUG "%s: VIDIOC_ENUMINPUT - index=%d\n",
3753 ZR_DEVNAME(zr), inp->index);
3754
3755 if (inp->index < 0 || inp->index >= zr->card.inputs)
3756 return -EINVAL;
3757 else {
3758 int id = inp->index;
3759 memset(inp, 0, sizeof(*inp));
3760 inp->index = id;
3761 }
3762
3763 strncpy(inp->name, zr->card.input[inp->index].name,
3764 sizeof(inp->name) - 1);
3765 inp->type = V4L2_INPUT_TYPE_CAMERA;
3766 inp->std = V4L2_STD_ALL;
3767
3768 /* Get status of video decoder */
3769 mutex_lock(&zr->resource_lock);
3770 decoder_command(zr, DECODER_GET_STATUS, &status);
3771 mutex_unlock(&zr->resource_lock);
3772
3773 if (!(status & DECODER_STATUS_GOOD)) {
3774 inp->status |= V4L2_IN_ST_NO_POWER;
3775 inp->status |= V4L2_IN_ST_NO_SIGNAL;
3776 }
3777 if (!(status & DECODER_STATUS_COLOR))
3778 inp->status |= V4L2_IN_ST_NO_COLOR;
3779
3780 return 0;
3781 }
3782 break;
3783
3784 case VIDIOC_G_INPUT:
3785 {
3786 int *input = arg;
3787
3788 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_INPUT\n", ZR_DEVNAME(zr));
3789
3790 mutex_lock(&zr->resource_lock);
3791 *input = zr->input;
3792 mutex_unlock(&zr->resource_lock);
3793
3794 return 0;
3795 }
3796 break;
3797
3798 case VIDIOC_S_INPUT:
3799 {
3800 int *input = arg, res = 0;
3801
3802 dprintk(3, KERN_DEBUG "%s: VIDIOC_S_INPUT - input=%d\n",
3803 ZR_DEVNAME(zr), *input);
3804
3805 mutex_lock(&zr->resource_lock);
3806 if ((res = zoran_set_input(zr, *input)))
3807 goto sinput_unlock_and_return;
3808
3809 /* Make sure the changes come into effect */
3810 res = wait_grab_pending(zr);
3811 sinput_unlock_and_return:
3812 mutex_unlock(&zr->resource_lock);
3813 return res;
3814 }
3815 break;
3816
3817 case VIDIOC_ENUMOUTPUT:
3818 {
3819 struct v4l2_output *outp = arg;
3820
3821 dprintk(3, KERN_DEBUG "%s: VIDIOC_ENUMOUTPUT - index=%d\n",
3822 ZR_DEVNAME(zr), outp->index);
3823
3824 if (outp->index != 0)
3825 return -EINVAL;
3826
3827 memset(outp, 0, sizeof(*outp));
3828 outp->index = 0;
3829 outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY;
3830 strncpy(outp->name, "Autodetect", sizeof(outp->name)-1);
3831
3832 return 0;
3833 }
3834 break;
3835
3836 case VIDIOC_G_OUTPUT:
3837 {
3838 int *output = arg;
3839
3840 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_OUTPUT\n", ZR_DEVNAME(zr));
3841
3842 *output = 0;
3843
3844 return 0;
3845 }
3846 break;
3847
3848 case VIDIOC_S_OUTPUT:
3849 {
3850 int *output = arg;
3851
3852 dprintk(3, KERN_DEBUG "%s: VIDIOC_S_OUTPUT - output=%d\n",
3853 ZR_DEVNAME(zr), *output);
3854
3855 if (*output != 0)
3856 return -EINVAL;
3857
3858 return 0;
3859 }
3860 break;
3861
3862 /* cropping (sub-frame capture) */
3863 case VIDIOC_CROPCAP:
3864 {
3865 struct v4l2_cropcap *cropcap = arg;
3866 int type = cropcap->type, res = 0;
3867
3868 dprintk(3, KERN_ERR "%s: VIDIOC_CROPCAP - type=%d\n",
3869 ZR_DEVNAME(zr), cropcap->type);
3870
3871 memset(cropcap, 0, sizeof(*cropcap));
3872 cropcap->type = type;
3873
3874 mutex_lock(&zr->resource_lock);
3875
3876 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
3877 (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
3878 fh->map_mode == ZORAN_MAP_MODE_RAW)) {
3879 dprintk(1,
3880 KERN_ERR
3881 "%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",
3882 ZR_DEVNAME(zr));
3883 res = -EINVAL;
3884 goto cropcap_unlock_and_return;
3885 }
3886
3887 cropcap->bounds.top = cropcap->bounds.left = 0;
3888 cropcap->bounds.width = BUZ_MAX_WIDTH;
3889 cropcap->bounds.height = BUZ_MAX_HEIGHT;
3890 cropcap->defrect.top = cropcap->defrect.left = 0;
3891 cropcap->defrect.width = BUZ_MIN_WIDTH;
3892 cropcap->defrect.height = BUZ_MIN_HEIGHT;
3893 cropcap_unlock_and_return:
3894 mutex_unlock(&zr->resource_lock);
3895 return res;
3896 }
3897 break;
3898
3899 case VIDIOC_G_CROP:
3900 {
3901 struct v4l2_crop *crop = arg;
3902 int type = crop->type, res = 0;
3903
3904 dprintk(3, KERN_ERR "%s: VIDIOC_G_CROP - type=%d\n",
3905 ZR_DEVNAME(zr), crop->type);
3906
3907 memset(crop, 0, sizeof(*crop));
3908 crop->type = type;
3909
3910 mutex_lock(&zr->resource_lock);
3911
3912 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
3913 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
3914 fh->map_mode == ZORAN_MAP_MODE_RAW)) {
3915 dprintk(1,
3916 KERN_ERR
3917 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
3918 ZR_DEVNAME(zr));
3919 res = -EINVAL;
3920 goto gcrop_unlock_and_return;
3921 }
3922
3923 crop->c.top = fh->jpg_settings.img_y;
3924 crop->c.left = fh->jpg_settings.img_x;
3925 crop->c.width = fh->jpg_settings.img_width;
3926 crop->c.height = fh->jpg_settings.img_height;
3927
3928 gcrop_unlock_and_return:
3929 mutex_unlock(&zr->resource_lock);
3930
3931 return res;
3932 }
3933 break;
3934
3935 case VIDIOC_S_CROP:
3936 {
3937 struct v4l2_crop *crop = arg;
3938 int res = 0;
3939
3940 settings = fh->jpg_settings;
3941
3942 dprintk(3,
3943 KERN_ERR
3944 "%s: VIDIOC_S_CROP - type=%d, x=%d,y=%d,w=%d,h=%d\n",
3945 ZR_DEVNAME(zr), crop->type, crop->c.left, crop->c.top,
3946 crop->c.width, crop->c.height);
3947
3948 mutex_lock(&zr->resource_lock);
3949
3950 if (fh->jpg_buffers.allocated || fh->v4l_buffers.allocated) {
3951 dprintk(1,
3952 KERN_ERR
3953 "%s: VIDIOC_S_CROP - cannot change settings while active\n",
3954 ZR_DEVNAME(zr));
3955 res = -EBUSY;
3956 goto scrop_unlock_and_return;
3957 }
3958
3959 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
3960 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
3961 fh->map_mode == ZORAN_MAP_MODE_RAW)) {
3962 dprintk(1,
3963 KERN_ERR
3964 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
3965 ZR_DEVNAME(zr));
3966 res = -EINVAL;
3967 goto scrop_unlock_and_return;
3968 }
3969
3970 /* move into a form that we understand */
3971 settings.img_x = crop->c.left;
3972 settings.img_y = crop->c.top;
3973 settings.img_width = crop->c.width;
3974 settings.img_height = crop->c.height;
3975
3976 /* check validity */
3977 if ((res = zoran_check_jpg_settings(zr, &settings)))
3978 goto scrop_unlock_and_return;
3979
3980 /* accept */
3981 fh->jpg_settings = settings;
3982
3983 scrop_unlock_and_return:
3984 mutex_unlock(&zr->resource_lock);
3985 return res;
3986 }
3987 break;
3988
3989 case VIDIOC_G_JPEGCOMP:
3990 {
3991 struct v4l2_jpegcompression *params = arg;
3992
3993 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_JPEGCOMP\n",
3994 ZR_DEVNAME(zr));
3995
3996 memset(params, 0, sizeof(*params));
3997
3998 mutex_lock(&zr->resource_lock);
3999
4000 params->quality = fh->jpg_settings.jpg_comp.quality;
4001 params->APPn = fh->jpg_settings.jpg_comp.APPn;
4002 memcpy(params->APP_data,
4003 fh->jpg_settings.jpg_comp.APP_data,
4004 fh->jpg_settings.jpg_comp.APP_len);
4005 params->APP_len = fh->jpg_settings.jpg_comp.APP_len;
4006 memcpy(params->COM_data,
4007 fh->jpg_settings.jpg_comp.COM_data,
4008 fh->jpg_settings.jpg_comp.COM_len);
4009 params->COM_len = fh->jpg_settings.jpg_comp.COM_len;
4010 params->jpeg_markers =
4011 fh->jpg_settings.jpg_comp.jpeg_markers;
4012
4013 mutex_unlock(&zr->resource_lock);
4014
4015 return 0;
4016 }
4017 break;
4018
4019 case VIDIOC_S_JPEGCOMP:
4020 {
4021 struct v4l2_jpegcompression *params = arg;
4022 int res = 0;
4023
4024 settings = fh->jpg_settings;
4025
4026 dprintk(3,
4027 KERN_DEBUG
4028 "%s: VIDIOC_S_JPEGCOMP - quality=%d, APPN=%d, APP_len=%d, COM_len=%d\n",
4029 ZR_DEVNAME(zr), params->quality, params->APPn,
4030 params->APP_len, params->COM_len);
4031
4032 settings.jpg_comp = *params;
4033
4034 mutex_lock(&zr->resource_lock);
4035
4036 if (fh->v4l_buffers.active != ZORAN_FREE ||
4037 fh->jpg_buffers.active != ZORAN_FREE) {
4038 dprintk(1,
4039 KERN_WARNING
4040 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
4041 ZR_DEVNAME(zr));
4042 res = -EBUSY;
4043 goto sjpegc_unlock_and_return;
4044 }
4045
4046 if ((res = zoran_check_jpg_settings(zr, &settings)))
4047 goto sjpegc_unlock_and_return;
4048 if (!fh->jpg_buffers.allocated)
4049 fh->jpg_buffers.buffer_size =
4050 zoran_v4l2_calc_bufsize(&fh->jpg_settings);
4051 fh->jpg_settings.jpg_comp = *params = settings.jpg_comp;
4052 sjpegc_unlock_and_return:
4053 mutex_unlock(&zr->resource_lock);
4054
4055 return 0;
4056 }
4057 break;
4058
4059 case VIDIOC_QUERYSTD: /* why is this useful? */
4060 {
4061 v4l2_std_id *std = arg;
4062
4063 dprintk(3,
4064 KERN_DEBUG "%s: VIDIOC_QUERY_STD - std=0x%llx\n",
4065 ZR_DEVNAME(zr), (unsigned long long)*std);
4066
4067 if (*std == V4L2_STD_ALL || *std == V4L2_STD_NTSC ||
4068 *std == V4L2_STD_PAL || (*std == V4L2_STD_SECAM &&
4069 zr->card.norms == 3)) {
4070 return 0;
4071 }
4072
4073 return -EINVAL;
4074 }
4075 break;
4076
4077 case VIDIOC_TRY_FMT:
4078 {
4079 struct v4l2_format *fmt = arg;
4080 int res = 0;
4081
4082 dprintk(3, KERN_DEBUG "%s: VIDIOC_TRY_FMT - type=%d\n",
4083 ZR_DEVNAME(zr), fmt->type);
4084
4085 switch (fmt->type) {
4086 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
4087 mutex_lock(&zr->resource_lock);
4088
4089 if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH)
4090 fmt->fmt.win.w.width = BUZ_MAX_WIDTH;
4091 if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH)
4092 fmt->fmt.win.w.width = BUZ_MIN_WIDTH;
4093 if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT)
4094 fmt->fmt.win.w.height = BUZ_MAX_HEIGHT;
4095 if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT)
4096 fmt->fmt.win.w.height = BUZ_MIN_HEIGHT;
4097
4098 mutex_unlock(&zr->resource_lock);
4099 break;
4100
4101 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
4102 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
4103 if (fmt->fmt.pix.bytesperline > 0)
4104 return -EINVAL;
4105
4106 mutex_lock(&zr->resource_lock);
4107
4108 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) {
4109 settings = fh->jpg_settings;
4110
4111 /* we actually need to set 'real' parameters now */
4112 if ((fmt->fmt.pix.height * 2) >
4113 BUZ_MAX_HEIGHT)
4114 settings.TmpDcm = 1;
4115 else
4116 settings.TmpDcm = 2;
4117 settings.decimation = 0;
4118 if (fmt->fmt.pix.height <=
4119 fh->jpg_settings.img_height / 2)
4120 settings.VerDcm = 2;
4121 else
4122 settings.VerDcm = 1;
4123 if (fmt->fmt.pix.width <=
4124 fh->jpg_settings.img_width / 4)
4125 settings.HorDcm = 4;
4126 else if (fmt->fmt.pix.width <=
4127 fh->jpg_settings.img_width / 2)
4128 settings.HorDcm = 2;
4129 else
4130 settings.HorDcm = 1;
4131 if (settings.TmpDcm == 1)
4132 settings.field_per_buff = 2;
4133 else
4134 settings.field_per_buff = 1;
4135
4136 /* check */
4137 if ((res =
4138 zoran_check_jpg_settings(zr,
4139 &settings)))
4140 goto tryfmt_unlock_and_return;
4141
4142 /* tell the user what we actually did */
4143 fmt->fmt.pix.width =
4144 settings.img_width / settings.HorDcm;
4145 fmt->fmt.pix.height =
4146 settings.img_height * 2 /
4147 (settings.TmpDcm * settings.VerDcm);
4148 if (settings.TmpDcm == 1)
4149 fmt->fmt.pix.field =
4150 (fh->jpg_settings.
4151 odd_even ? V4L2_FIELD_SEQ_TB :
4152 V4L2_FIELD_SEQ_BT);
4153 else
4154 fmt->fmt.pix.field =
4155 (fh->jpg_settings.
4156 odd_even ? V4L2_FIELD_TOP :
4157 V4L2_FIELD_BOTTOM);
4158
4159 fmt->fmt.pix.sizeimage =
4160 zoran_v4l2_calc_bufsize(&settings);
4161 } else if (fmt->type ==
4162 V4L2_BUF_TYPE_VIDEO_CAPTURE) {
4163 int i;
4164
4165 for (i = 0; i < NUM_FORMATS; i++)
4166 if (zoran_formats[i].fourcc ==
4167 fmt->fmt.pix.pixelformat)
4168 break;
4169 if (i == NUM_FORMATS) {
4170 res = -EINVAL;
4171 goto tryfmt_unlock_and_return;
4172 }
4173
4174 if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
4175 fmt->fmt.pix.width = BUZ_MAX_WIDTH;
4176 if (fmt->fmt.pix.width < BUZ_MIN_WIDTH)
4177 fmt->fmt.pix.width = BUZ_MIN_WIDTH;
4178 if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
4179 fmt->fmt.pix.height =
4180 BUZ_MAX_HEIGHT;
4181 if (fmt->fmt.pix.height < BUZ_MIN_HEIGHT)
4182 fmt->fmt.pix.height =
4183 BUZ_MIN_HEIGHT;
4184 } else {
4185 res = -EINVAL;
4186 goto tryfmt_unlock_and_return;
4187 }
4188 tryfmt_unlock_and_return:
4189 mutex_unlock(&zr->resource_lock);
4190
4191 return res;
4192 break;
4193
4194 default:
4195 return -EINVAL;
4196 }
4197
4198 return 0;
4199 }
4200 break;
4201 #endif
4202
4203 default:
4204 dprintk(1, KERN_DEBUG "%s: UNKNOWN ioctl cmd: 0x%x\n",
4205 ZR_DEVNAME(zr), cmd);
4206 return -ENOIOCTLCMD;
4207 break;
4208
4209 }
4210 return 0;
4211 }
4212
4213
4214 static int
4215 zoran_ioctl (struct inode *inode,
4216 struct file *file,
4217 unsigned int cmd,
4218 unsigned long arg)
4219 {
4220 return video_usercopy(inode, file, cmd, arg, zoran_do_ioctl);
4221 }
4222
4223 static unsigned int
4224 zoran_poll (struct file *file,
4225 poll_table *wait)
4226 {
4227 struct zoran_fh *fh = file->private_data;
4228 struct zoran *zr = fh->zr;
4229 int res = 0, frame;
4230 unsigned long flags;
4231
4232 /* we should check whether buffers are ready to be synced on
4233 * (w/o waits - O_NONBLOCK) here
4234 * if ready for read (sync), return POLLIN|POLLRDNORM,
4235 * if ready for write (sync), return POLLOUT|POLLWRNORM,
4236 * if error, return POLLERR,
4237 * if no buffers queued or so, return POLLNVAL
4238 */
4239
4240 mutex_lock(&zr->resource_lock);
4241
4242 switch (fh->map_mode) {
4243 case ZORAN_MAP_MODE_RAW:
4244 poll_wait(file, &zr->v4l_capq, wait);
4245 frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
4246
4247 spin_lock_irqsave(&zr->spinlock, flags);
4248 dprintk(3,
4249 KERN_DEBUG
4250 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
4251 ZR_DEVNAME(zr), __FUNCTION__,
4252 "FAL"[fh->v4l_buffers.active], zr->v4l_sync_tail,
4253 "UPMD"[zr->v4l_buffers.buffer[frame].state],
4254 zr->v4l_pend_tail, zr->v4l_pend_head);
4255 /* Process is the one capturing? */
4256 if (fh->v4l_buffers.active != ZORAN_FREE &&
4257 /* Buffer ready to DQBUF? */
4258 zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE)
4259 res = POLLIN | POLLRDNORM;
4260 spin_unlock_irqrestore(&zr->spinlock, flags);
4261
4262 break;
4263
4264 case ZORAN_MAP_MODE_JPG_REC:
4265 case ZORAN_MAP_MODE_JPG_PLAY:
4266 poll_wait(file, &zr->jpg_capq, wait);
4267 frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
4268
4269 spin_lock_irqsave(&zr->spinlock, flags);
4270 dprintk(3,
4271 KERN_DEBUG
4272 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
4273 ZR_DEVNAME(zr), __FUNCTION__,
4274 "FAL"[fh->jpg_buffers.active], zr->jpg_que_tail,
4275 "UPMD"[zr->jpg_buffers.buffer[frame].state],
4276 zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head);
4277 if (fh->jpg_buffers.active != ZORAN_FREE &&
4278 zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) {
4279 if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC)
4280 res = POLLIN | POLLRDNORM;
4281 else
4282 res = POLLOUT | POLLWRNORM;
4283 }
4284 spin_unlock_irqrestore(&zr->spinlock, flags);
4285
4286 break;
4287
4288 default:
4289 dprintk(1,
4290 KERN_ERR
4291 "%s: zoran_poll() - internal error, unknown map_mode=%d\n",
4292 ZR_DEVNAME(zr), fh->map_mode);
4293 res = POLLNVAL;
4294 }
4295
4296 mutex_unlock(&zr->resource_lock);
4297
4298 return res;
4299 }
4300
4301
4302 /*
4303 * This maps the buffers to user space.
4304 *
4305 * Depending on the state of fh->map_mode
4306 * the V4L or the MJPEG buffers are mapped
4307 * per buffer or all together
4308 *
4309 * Note that we need to connect to some
4310 * unmap signal event to unmap the de-allocate
4311 * the buffer accordingly (zoran_vm_close())
4312 */
4313
4314 static void
4315 zoran_vm_open (struct vm_area_struct *vma)
4316 {
4317 struct zoran_mapping *map = vma->vm_private_data;
4318
4319 map->count++;
4320 }
4321
4322 static void
4323 zoran_vm_close (struct vm_area_struct *vma)
4324 {
4325 struct zoran_mapping *map = vma->vm_private_data;
4326 struct file *file = map->file;
4327 struct zoran_fh *fh = file->private_data;
4328 struct zoran *zr = fh->zr;
4329 int i;
4330
4331 map->count--;
4332 if (map->count == 0) {
4333 switch (fh->map_mode) {
4334 case ZORAN_MAP_MODE_JPG_REC:
4335 case ZORAN_MAP_MODE_JPG_PLAY:
4336
4337 dprintk(3, KERN_INFO "%s: munmap(MJPEG)\n",
4338 ZR_DEVNAME(zr));
4339
4340 for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {
4341 if (fh->jpg_buffers.buffer[i].map == map) {
4342 fh->jpg_buffers.buffer[i].map =
4343 NULL;
4344 }
4345 }
4346 kfree(map);
4347
4348 for (i = 0; i < fh->jpg_buffers.num_buffers; i++)
4349 if (fh->jpg_buffers.buffer[i].map)
4350 break;
4351 if (i == fh->jpg_buffers.num_buffers) {
4352 mutex_lock(&zr->resource_lock);
4353
4354 if (fh->jpg_buffers.active != ZORAN_FREE) {
4355 jpg_qbuf(file, -1, zr->codec_mode);
4356 zr->jpg_buffers.allocated = 0;
4357 zr->jpg_buffers.active =
4358 fh->jpg_buffers.active =
4359 ZORAN_FREE;
4360 }
4361 //jpg_fbuffer_free(file);
4362 fh->jpg_buffers.allocated = 0;
4363 fh->jpg_buffers.ready_to_be_freed = 1;
4364
4365 mutex_unlock(&zr->resource_lock);
4366 }
4367
4368 break;
4369
4370 case ZORAN_MAP_MODE_RAW:
4371
4372 dprintk(3, KERN_INFO "%s: munmap(V4L)\n",
4373 ZR_DEVNAME(zr));
4374
4375 for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {
4376 if (fh->v4l_buffers.buffer[i].map == map) {
4377 /* unqueue/unmap */
4378 fh->v4l_buffers.buffer[i].map =
4379 NULL;
4380 }
4381 }
4382 kfree(map);
4383
4384 for (i = 0; i < fh->v4l_buffers.num_buffers; i++)
4385 if (fh->v4l_buffers.buffer[i].map)
4386 break;
4387 if (i == fh->v4l_buffers.num_buffers) {
4388 mutex_lock(&zr->resource_lock);
4389
4390 if (fh->v4l_buffers.active != ZORAN_FREE) {
4391 long flags;
4392
4393 spin_lock_irqsave(&zr->spinlock, flags);
4394 zr36057_set_memgrab(zr, 0);
4395 zr->v4l_buffers.allocated = 0;
4396 zr->v4l_buffers.active =
4397 fh->v4l_buffers.active =
4398 ZORAN_FREE;
4399 spin_unlock_irqrestore(&zr->spinlock, flags);
4400 }
4401 //v4l_fbuffer_free(file);
4402 fh->v4l_buffers.allocated = 0;
4403 fh->v4l_buffers.ready_to_be_freed = 1;
4404
4405 mutex_unlock(&zr->resource_lock);
4406 }
4407
4408 break;
4409
4410 default:
4411 printk(KERN_ERR
4412 "%s: munmap() - internal error - unknown map mode %d\n",
4413 ZR_DEVNAME(zr), fh->map_mode);
4414 break;
4415
4416 }
4417 }
4418 }
4419
4420 static struct vm_operations_struct zoran_vm_ops = {
4421 .open = zoran_vm_open,
4422 .close = zoran_vm_close,
4423 };
4424
4425 static int
4426 zoran_mmap (struct file *file,
4427 struct vm_area_struct *vma)
4428 {
4429 struct zoran_fh *fh = file->private_data;
4430 struct zoran *zr = fh->zr;
4431 unsigned long size = (vma->vm_end - vma->vm_start);
4432 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
4433 int i, j;
4434 unsigned long page, start = vma->vm_start, todo, pos, fraglen;
4435 int first, last;
4436 struct zoran_mapping *map;
4437 int res = 0;
4438
4439 dprintk(3,
4440 KERN_INFO "%s: mmap(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
4441 ZR_DEVNAME(zr),
4442 fh->map_mode == ZORAN_MAP_MODE_RAW ? "V4L" : "MJPEG",
4443 vma->vm_start, vma->vm_end, size);
4444
4445 if (!(vma->vm_flags & VM_SHARED) || !(vma->vm_flags & VM_READ) ||
4446 !(vma->vm_flags & VM_WRITE)) {
4447 dprintk(1,
4448 KERN_ERR
4449 "%s: mmap() - no MAP_SHARED/PROT_{READ,WRITE} given\n",
4450 ZR_DEVNAME(zr));
4451 return -EINVAL;
4452 }
4453
4454 switch (fh->map_mode) {
4455
4456 case ZORAN_MAP_MODE_JPG_REC:
4457 case ZORAN_MAP_MODE_JPG_PLAY:
4458
4459 /* lock */
4460 mutex_lock(&zr->resource_lock);
4461
4462 /* Map the MJPEG buffers */
4463 if (!fh->jpg_buffers.allocated) {
4464 dprintk(1,
4465 KERN_ERR
4466 "%s: zoran_mmap(MJPEG) - buffers not yet allocated\n",
4467 ZR_DEVNAME(zr));
4468 res = -ENOMEM;
4469 goto jpg_mmap_unlock_and_return;
4470 }
4471
4472 first = offset / fh->jpg_buffers.buffer_size;
4473 last = first - 1 + size / fh->jpg_buffers.buffer_size;
4474 if (offset % fh->jpg_buffers.buffer_size != 0 ||
4475 size % fh->jpg_buffers.buffer_size != 0 || first < 0 ||
4476 last < 0 || first >= fh->jpg_buffers.num_buffers ||
4477 last >= fh->jpg_buffers.num_buffers) {
4478 dprintk(1,
4479 KERN_ERR
4480 "%s: mmap(MJPEG) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
4481 ZR_DEVNAME(zr), offset, size,
4482 fh->jpg_buffers.buffer_size,
4483 fh->jpg_buffers.num_buffers);
4484 res = -EINVAL;
4485 goto jpg_mmap_unlock_and_return;
4486 }
4487 for (i = first; i <= last; i++) {
4488 if (fh->jpg_buffers.buffer[i].map) {
4489 dprintk(1,
4490 KERN_ERR
4491 "%s: mmap(MJPEG) - buffer %d already mapped\n",
4492 ZR_DEVNAME(zr), i);
4493 res = -EBUSY;
4494 goto jpg_mmap_unlock_and_return;
4495 }
4496 }
4497
4498 /* map these buffers (v4l_buffers[i]) */
4499 map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);
4500 if (!map) {
4501 res = -ENOMEM;
4502 goto jpg_mmap_unlock_and_return;
4503 }
4504 map->file = file;
4505 map->count = 1;
4506
4507 vma->vm_ops = &zoran_vm_ops;
4508 vma->vm_flags |= VM_DONTEXPAND;
4509 vma->vm_private_data = map;
4510
4511 for (i = first; i <= last; i++) {
4512 for (j = 0;
4513 j < fh->jpg_buffers.buffer_size / PAGE_SIZE;
4514 j++) {
4515 fraglen =
4516 (le32_to_cpu(fh->jpg_buffers.buffer[i].
4517 frag_tab[2 * j + 1]) & ~1) << 1;
4518 todo = size;
4519 if (todo > fraglen)
4520 todo = fraglen;
4521 pos =
4522 le32_to_cpu((unsigned long) fh->jpg_buffers.
4523 buffer[i].frag_tab[2 * j]);
4524 /* should just be pos on i386 */
4525 page = virt_to_phys(bus_to_virt(pos))
4526 >> PAGE_SHIFT;
4527 if (remap_pfn_range(vma, start, page,
4528 todo, PAGE_SHARED)) {
4529 dprintk(1,
4530 KERN_ERR
4531 "%s: zoran_mmap(V4L) - remap_pfn_range failed\n",
4532 ZR_DEVNAME(zr));
4533 res = -EAGAIN;
4534 goto jpg_mmap_unlock_and_return;
4535 }
4536 size -= todo;
4537 start += todo;
4538 if (size == 0)
4539 break;
4540 if (le32_to_cpu(fh->jpg_buffers.buffer[i].
4541 frag_tab[2 * j + 1]) & 1)
4542 break; /* was last fragment */
4543 }
4544 fh->jpg_buffers.buffer[i].map = map;
4545 if (size == 0)
4546 break;
4547
4548 }
4549 jpg_mmap_unlock_and_return:
4550 mutex_unlock(&zr->resource_lock);
4551
4552 break;
4553
4554 case ZORAN_MAP_MODE_RAW:
4555
4556 mutex_lock(&zr->resource_lock);
4557
4558 /* Map the V4L buffers */
4559 if (!fh->v4l_buffers.allocated) {
4560 dprintk(1,
4561 KERN_ERR
4562 "%s: zoran_mmap(V4L) - buffers not yet allocated\n",
4563 ZR_DEVNAME(zr));
4564 res = -ENOMEM;
4565 goto v4l_mmap_unlock_and_return;
4566 }
4567
4568 first = offset / fh->v4l_buffers.buffer_size;
4569 last = first - 1 + size / fh->v4l_buffers.buffer_size;
4570 if (offset % fh->v4l_buffers.buffer_size != 0 ||
4571 size % fh->v4l_buffers.buffer_size != 0 || first < 0 ||
4572 last < 0 || first >= fh->v4l_buffers.num_buffers ||
4573 last >= fh->v4l_buffers.buffer_size) {
4574 dprintk(1,
4575 KERN_ERR
4576 "%s: mmap(V4L) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
4577 ZR_DEVNAME(zr), offset, size,
4578 fh->v4l_buffers.buffer_size,
4579 fh->v4l_buffers.num_buffers);
4580 res = -EINVAL;
4581 goto v4l_mmap_unlock_and_return;
4582 }
4583 for (i = first; i <= last; i++) {
4584 if (fh->v4l_buffers.buffer[i].map) {
4585 dprintk(1,
4586 KERN_ERR
4587 "%s: mmap(V4L) - buffer %d already mapped\n",
4588 ZR_DEVNAME(zr), i);
4589 res = -EBUSY;
4590 goto v4l_mmap_unlock_and_return;
4591 }
4592 }
4593
4594 /* map these buffers (v4l_buffers[i]) */
4595 map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);
4596 if (!map) {
4597 res = -ENOMEM;
4598 goto v4l_mmap_unlock_and_return;
4599 }
4600 map->file = file;
4601 map->count = 1;
4602
4603 vma->vm_ops = &zoran_vm_ops;
4604 vma->vm_flags |= VM_DONTEXPAND;
4605 vma->vm_private_data = map;
4606
4607 for (i = first; i <= last; i++) {
4608 todo = size;
4609 if (todo > fh->v4l_buffers.buffer_size)
4610 todo = fh->v4l_buffers.buffer_size;
4611 page = fh->v4l_buffers.buffer[i].fbuffer_phys;
4612 if (remap_pfn_range(vma, start, page >> PAGE_SHIFT,
4613 todo, PAGE_SHARED)) {
4614 dprintk(1,
4615 KERN_ERR
4616 "%s: zoran_mmap(V4L)i - remap_pfn_range failed\n",
4617 ZR_DEVNAME(zr));
4618 res = -EAGAIN;
4619 goto v4l_mmap_unlock_and_return;
4620 }
4621 size -= todo;
4622 start += todo;
4623 fh->v4l_buffers.buffer[i].map = map;
4624 if (size == 0)
4625 break;
4626 }
4627 v4l_mmap_unlock_and_return:
4628 mutex_unlock(&zr->resource_lock);
4629
4630 break;
4631
4632 default:
4633 dprintk(1,
4634 KERN_ERR
4635 "%s: zoran_mmap() - internal error - unknown map mode %d\n",
4636 ZR_DEVNAME(zr), fh->map_mode);
4637 break;
4638 }
4639
4640 return 0;
4641 }
4642
4643 static const struct file_operations zoran_fops = {
4644 .owner = THIS_MODULE,
4645 .open = zoran_open,
4646 .release = zoran_close,
4647 .ioctl = zoran_ioctl,
4648 .compat_ioctl = v4l_compat_ioctl32,
4649 .llseek = no_llseek,
4650 .read = zoran_read,
4651 .write = zoran_write,
4652 .mmap = zoran_mmap,
4653 .poll = zoran_poll,
4654 };
4655
4656 struct video_device zoran_template __devinitdata = {
4657 .name = ZORAN_NAME,
4658 .type = ZORAN_VID_TYPE,
4659 #ifdef CONFIG_VIDEO_V4L2
4660 .type2 = ZORAN_V4L2_VID_FLAGS,
4661 #endif
4662 .hardware = ZORAN_HARDWARE,
4663 .fops = &zoran_fops,
4664 .release = &zoran_vdev_release,
4665 .minor = -1
4666 };
4667
Ubuntu Focal Linux kernel mirror