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