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_SECAM)
1460 zr->timing = zr->card.tvn[2];
1461 else if (norm & V4L2_STD_NTSC)
1462 zr->timing = zr->card.tvn[1];
1463 else
1464 zr->timing = zr->card.tvn[0];
1465
1466
1467
1468 on = zr->overlay_active && !zr->v4l_memgrab_active;
1469 if (on)
1470 zr36057_overlay(zr, 0);
1471
1472 decoder_call(zr, core, s_std, norm);
1473 encoder_call(zr, video, s_std_output, norm);
1474
1475 if (on)
1476 zr36057_overlay(zr, 1);
1477
1478
1479 zr->norm = norm;
1480
1481 return 0;
1482}
1483
1484static int
1485zoran_set_input (struct zoran *zr,
1486 int input)
1487{
1488 if (input == zr->input) {
1489 return 0;
1490 }
1491
1492 if (zr->v4l_buffers.active != ZORAN_FREE ||
1493 zr->jpg_buffers.active != ZORAN_FREE) {
1494 dprintk(1,
1495 KERN_WARNING
1496 "%s: %s called while in playback/capture mode\n",
1497 ZR_DEVNAME(zr), __func__);
1498 return -EBUSY;
1499 }
1500
1501 if (input < 0 || input >= zr->card.inputs) {
1502 dprintk(1,
1503 KERN_ERR
1504 "%s: %s - unnsupported input %d\n",
1505 ZR_DEVNAME(zr), __func__, input);
1506 return -EINVAL;
1507 }
1508
1509 zr->input = input;
1510
1511 decoder_call(zr, video, s_routing,
1512 zr->card.input[input].muxsel, 0, 0);
1513
1514 return 0;
1515}
1516
1517
1518
1519
1520
1521static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability *cap)
1522{
1523 struct zoran_fh *fh = __fh;
1524 struct zoran *zr = fh->zr;
1525
1526 memset(cap, 0, sizeof(*cap));
1527 strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1);
1528 strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);
1529 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
1530 pci_name(zr->pci_dev));
1531 cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE |
1532 V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OVERLAY;
1533 return 0;
1534}
1535
1536static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag)
1537{
1538 unsigned int num, i;
1539
1540 for (num = i = 0; i < NUM_FORMATS; i++) {
1541 if (zoran_formats[i].flags & flag && num++ == fmt->index) {
1542 strncpy(fmt->description, zoran_formats[i].name,
1543 sizeof(fmt->description) - 1);
1544
1545 fmt->pixelformat = zoran_formats[i].fourcc;
1546 if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
1547 fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
1548 return 0;
1549 }
1550 }
1551 return -EINVAL;
1552}
1553
1554static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh,
1555 struct v4l2_fmtdesc *f)
1556{
1557 struct zoran_fh *fh = __fh;
1558 struct zoran *zr = fh->zr;
1559
1560 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE);
1561}
1562
1563static int zoran_enum_fmt_vid_out(struct file *file, void *__fh,
1564 struct v4l2_fmtdesc *f)
1565{
1566 struct zoran_fh *fh = __fh;
1567 struct zoran *zr = fh->zr;
1568
1569 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_PLAYBACK);
1570}
1571
1572static int zoran_enum_fmt_vid_overlay(struct file *file, void *__fh,
1573 struct v4l2_fmtdesc *f)
1574{
1575 struct zoran_fh *fh = __fh;
1576 struct zoran *zr = fh->zr;
1577
1578 return zoran_enum_fmt(zr, f, ZORAN_FORMAT_OVERLAY);
1579}
1580
1581static int zoran_g_fmt_vid_out(struct file *file, void *__fh,
1582 struct v4l2_format *fmt)
1583{
1584 struct zoran_fh *fh = __fh;
1585 struct zoran *zr = fh->zr;
1586
1587 mutex_lock(&zr->resource_lock);
1588
1589 fmt->fmt.pix.width = fh->jpg_settings.img_width / fh->jpg_settings.HorDcm;
1590 fmt->fmt.pix.height = fh->jpg_settings.img_height * 2 /
1591 (fh->jpg_settings.VerDcm * fh->jpg_settings.TmpDcm);
1592 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
1593 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1594 if (fh->jpg_settings.TmpDcm == 1)
1595 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1596 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
1597 else
1598 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1599 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1600 fmt->fmt.pix.bytesperline = 0;
1601 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1602
1603 mutex_unlock(&zr->resource_lock);
1604 return 0;
1605}
1606
1607static int zoran_g_fmt_vid_cap(struct file *file, void *__fh,
1608 struct v4l2_format *fmt)
1609{
1610 struct zoran_fh *fh = __fh;
1611 struct zoran *zr = fh->zr;
1612
1613 if (fh->map_mode != ZORAN_MAP_MODE_RAW)
1614 return zoran_g_fmt_vid_out(file, fh, fmt);
1615
1616 mutex_lock(&zr->resource_lock);
1617 fmt->fmt.pix.width = fh->v4l_settings.width;
1618 fmt->fmt.pix.height = fh->v4l_settings.height;
1619 fmt->fmt.pix.sizeimage = fh->v4l_settings.bytesperline *
1620 fh->v4l_settings.height;
1621 fmt->fmt.pix.pixelformat = fh->v4l_settings.format->fourcc;
1622 fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;
1623 fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;
1624 if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))
1625 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
1626 else
1627 fmt->fmt.pix.field = V4L2_FIELD_TOP;
1628 mutex_unlock(&zr->resource_lock);
1629 return 0;
1630}
1631
1632static int zoran_g_fmt_vid_overlay(struct file *file, void *__fh,
1633 struct v4l2_format *fmt)
1634{
1635 struct zoran_fh *fh = __fh;
1636 struct zoran *zr = fh->zr;
1637
1638 mutex_lock(&zr->resource_lock);
1639
1640 fmt->fmt.win.w.left = fh->overlay_settings.x;
1641 fmt->fmt.win.w.top = fh->overlay_settings.y;
1642 fmt->fmt.win.w.width = fh->overlay_settings.width;
1643 fmt->fmt.win.w.height = fh->overlay_settings.height;
1644 if (fh->overlay_settings.width * 2 > BUZ_MAX_HEIGHT)
1645 fmt->fmt.win.field = V4L2_FIELD_INTERLACED;
1646 else
1647 fmt->fmt.win.field = V4L2_FIELD_TOP;
1648
1649 mutex_unlock(&zr->resource_lock);
1650 return 0;
1651}
1652
1653static int zoran_try_fmt_vid_overlay(struct file *file, void *__fh,
1654 struct v4l2_format *fmt)
1655{
1656 struct zoran_fh *fh = __fh;
1657 struct zoran *zr = fh->zr;
1658
1659 mutex_lock(&zr->resource_lock);
1660
1661 if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH)
1662 fmt->fmt.win.w.width = BUZ_MAX_WIDTH;
1663 if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH)
1664 fmt->fmt.win.w.width = BUZ_MIN_WIDTH;
1665 if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT)
1666 fmt->fmt.win.w.height = BUZ_MAX_HEIGHT;
1667 if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT)
1668 fmt->fmt.win.w.height = BUZ_MIN_HEIGHT;
1669
1670 mutex_unlock(&zr->resource_lock);
1671 return 0;
1672}
1673
1674static int zoran_try_fmt_vid_out(struct file *file, void *__fh,
1675 struct v4l2_format *fmt)
1676{
1677 struct zoran_fh *fh = __fh;
1678 struct zoran *zr = fh->zr;
1679 struct zoran_jpg_settings settings;
1680 int res = 0;
1681
1682 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1683 return -EINVAL;
1684
1685 mutex_lock(&zr->resource_lock);
1686 settings = fh->jpg_settings;
1687
1688
1689 if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT)
1690 settings.TmpDcm = 1;
1691 else
1692 settings.TmpDcm = 2;
1693 settings.decimation = 0;
1694 if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)
1695 settings.VerDcm = 2;
1696 else
1697 settings.VerDcm = 1;
1698 if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)
1699 settings.HorDcm = 4;
1700 else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)
1701 settings.HorDcm = 2;
1702 else
1703 settings.HorDcm = 1;
1704 if (settings.TmpDcm == 1)
1705 settings.field_per_buff = 2;
1706 else
1707 settings.field_per_buff = 1;
1708
1709 if (settings.HorDcm > 1) {
1710 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
1711 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
1712 } else {
1713 settings.img_x = 0;
1714 settings.img_width = BUZ_MAX_WIDTH;
1715 }
1716
1717
1718 res = zoran_check_jpg_settings(zr, &settings, 1);
1719 if (res)
1720 goto tryfmt_unlock_and_return;
1721
1722
1723 fmt->fmt.pix.width = settings.img_width / settings.HorDcm;
1724 fmt->fmt.pix.height = settings.img_height * 2 /
1725 (settings.TmpDcm * settings.VerDcm);
1726 if (settings.TmpDcm == 1)
1727 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1728 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
1729 else
1730 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1731 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1732
1733 fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings);
1734 fmt->fmt.pix.bytesperline = 0;
1735 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1736tryfmt_unlock_and_return:
1737 mutex_unlock(&zr->resource_lock);
1738 return res;
1739}
1740
1741static int zoran_try_fmt_vid_cap(struct file *file, void *__fh,
1742 struct v4l2_format *fmt)
1743{
1744 struct zoran_fh *fh = __fh;
1745 struct zoran *zr = fh->zr;
1746 int bpp;
1747 int i;
1748
1749 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
1750 return zoran_try_fmt_vid_out(file, fh, fmt);
1751
1752 mutex_lock(&zr->resource_lock);
1753
1754 for (i = 0; i < NUM_FORMATS; i++)
1755 if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat)
1756 break;
1757
1758 if (i == NUM_FORMATS) {
1759 mutex_unlock(&zr->resource_lock);
1760 return -EINVAL;
1761 }
1762
1763 bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8);
1764 v4l_bound_align_image(
1765 &fmt->fmt.pix.width, BUZ_MIN_WIDTH, BUZ_MAX_WIDTH, bpp == 2 ? 1 : 2,
1766 &fmt->fmt.pix.height, BUZ_MIN_HEIGHT, BUZ_MAX_HEIGHT, 0, 0);
1767 mutex_unlock(&zr->resource_lock);
1768
1769 return 0;
1770}
1771
1772static int zoran_s_fmt_vid_overlay(struct file *file, void *__fh,
1773 struct v4l2_format *fmt)
1774{
1775 struct zoran_fh *fh = __fh;
1776 struct zoran *zr = fh->zr;
1777 int res;
1778
1779 dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
1780 fmt->fmt.win.w.left, fmt->fmt.win.w.top,
1781 fmt->fmt.win.w.width,
1782 fmt->fmt.win.w.height,
1783 fmt->fmt.win.clipcount,
1784 fmt->fmt.win.bitmap);
1785 mutex_lock(&zr->resource_lock);
1786 res = setup_window(fh, fmt->fmt.win.w.left, fmt->fmt.win.w.top,
1787 fmt->fmt.win.w.width, fmt->fmt.win.w.height,
1788 (struct v4l2_clip __user *)fmt->fmt.win.clips,
1789 fmt->fmt.win.clipcount, fmt->fmt.win.bitmap);
1790 mutex_unlock(&zr->resource_lock);
1791 return res;
1792}
1793
1794static int zoran_s_fmt_vid_out(struct file *file, void *__fh,
1795 struct v4l2_format *fmt)
1796{
1797 struct zoran_fh *fh = __fh;
1798 struct zoran *zr = fh->zr;
1799 __le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat);
1800 struct zoran_jpg_settings settings;
1801 int res = 0;
1802
1803 dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
1804 fmt->fmt.pix.width, fmt->fmt.pix.height,
1805 fmt->fmt.pix.pixelformat,
1806 (char *) &printformat);
1807 if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1808 return -EINVAL;
1809
1810 mutex_lock(&zr->resource_lock);
1811
1812 if (fh->buffers.allocated) {
1813 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",
1814 ZR_DEVNAME(zr));
1815 res = -EBUSY;
1816 goto sfmtjpg_unlock_and_return;
1817 }
1818
1819 settings = fh->jpg_settings;
1820
1821
1822 if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT)
1823 settings.TmpDcm = 1;
1824 else
1825 settings.TmpDcm = 2;
1826 settings.decimation = 0;
1827 if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)
1828 settings.VerDcm = 2;
1829 else
1830 settings.VerDcm = 1;
1831 if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)
1832 settings.HorDcm = 4;
1833 else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)
1834 settings.HorDcm = 2;
1835 else
1836 settings.HorDcm = 1;
1837 if (settings.TmpDcm == 1)
1838 settings.field_per_buff = 2;
1839 else
1840 settings.field_per_buff = 1;
1841
1842 if (settings.HorDcm > 1) {
1843 settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
1844 settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
1845 } else {
1846 settings.img_x = 0;
1847 settings.img_width = BUZ_MAX_WIDTH;
1848 }
1849
1850
1851 res = zoran_check_jpg_settings(zr, &settings, 0);
1852 if (res)
1853 goto sfmtjpg_unlock_and_return;
1854
1855
1856 fh->jpg_settings = settings;
1857
1858 map_mode_jpg(fh, fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT);
1859 fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
1860
1861
1862 fmt->fmt.pix.width = settings.img_width / settings.HorDcm;
1863 fmt->fmt.pix.height = settings.img_height * 2 /
1864 (settings.TmpDcm * settings.VerDcm);
1865 if (settings.TmpDcm == 1)
1866 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1867 V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
1868 else
1869 fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
1870 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
1871 fmt->fmt.pix.bytesperline = 0;
1872 fmt->fmt.pix.sizeimage = fh->buffers.buffer_size;
1873 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1874
1875sfmtjpg_unlock_and_return:
1876 mutex_unlock(&zr->resource_lock);
1877 return res;
1878}
1879
1880static int zoran_s_fmt_vid_cap(struct file *file, void *__fh,
1881 struct v4l2_format *fmt)
1882{
1883 struct zoran_fh *fh = __fh;
1884 struct zoran *zr = fh->zr;
1885 int i;
1886 int res = 0;
1887
1888 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
1889 return zoran_s_fmt_vid_out(file, fh, fmt);
1890
1891 for (i = 0; i < NUM_FORMATS; i++)
1892 if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc)
1893 break;
1894 if (i == NUM_FORMATS) {
1895 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",
1896 ZR_DEVNAME(zr), fmt->fmt.pix.pixelformat);
1897 return -EINVAL;
1898 }
1899
1900 mutex_lock(&zr->resource_lock);
1901
1902 if ((fh->map_mode != ZORAN_MAP_MODE_RAW && fh->buffers.allocated) ||
1903 fh->buffers.active != ZORAN_FREE) {
1904 dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",
1905 ZR_DEVNAME(zr));
1906 res = -EBUSY;
1907 goto sfmtv4l_unlock_and_return;
1908 }
1909 if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
1910 fmt->fmt.pix.height = BUZ_MAX_HEIGHT;
1911 if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
1912 fmt->fmt.pix.width = BUZ_MAX_WIDTH;
1913
1914 map_mode_raw(fh);
1915
1916 res = zoran_v4l_set_format(fh, fmt->fmt.pix.width, fmt->fmt.pix.height,
1917 &zoran_formats[i]);
1918 if (res)
1919 goto sfmtv4l_unlock_and_return;
1920
1921
1922 fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;
1923 fmt->fmt.pix.sizeimage = fh->v4l_settings.height * fh->v4l_settings.bytesperline;
1924 fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;
1925 if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))
1926 fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
1927 else
1928 fmt->fmt.pix.field = V4L2_FIELD_TOP;
1929
1930sfmtv4l_unlock_and_return:
1931 mutex_unlock(&zr->resource_lock);
1932 return res;
1933}
1934
1935static int zoran_g_fbuf(struct file *file, void *__fh,
1936 struct v4l2_framebuffer *fb)
1937{
1938 struct zoran_fh *fh = __fh;
1939 struct zoran *zr = fh->zr;
1940
1941 memset(fb, 0, sizeof(*fb));
1942 mutex_lock(&zr->resource_lock);
1943 fb->base = zr->vbuf_base;
1944 fb->fmt.width = zr->vbuf_width;
1945 fb->fmt.height = zr->vbuf_height;
1946 if (zr->overlay_settings.format)
1947 fb->fmt.pixelformat = fh->overlay_settings.format->fourcc;
1948 fb->fmt.bytesperline = zr->vbuf_bytesperline;
1949 mutex_unlock(&zr->resource_lock);
1950 fb->fmt.colorspace = V4L2_COLORSPACE_SRGB;
1951 fb->fmt.field = V4L2_FIELD_INTERLACED;
1952 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
1953
1954 return 0;
1955}
1956
1957static int zoran_s_fbuf(struct file *file, void *__fh,
1958 const struct v4l2_framebuffer *fb)
1959{
1960 struct zoran_fh *fh = __fh;
1961 struct zoran *zr = fh->zr;
1962 int i, res = 0;
1963 __le32 printformat = __cpu_to_le32(fb->fmt.pixelformat);
1964
1965 for (i = 0; i < NUM_FORMATS; i++)
1966 if (zoran_formats[i].fourcc == fb->fmt.pixelformat)
1967 break;
1968 if (i == NUM_FORMATS) {
1969 dprintk(1, KERN_ERR "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
1970 ZR_DEVNAME(zr), fb->fmt.pixelformat,
1971 (char *)&printformat);
1972 return -EINVAL;
1973 }
1974
1975 mutex_lock(&zr->resource_lock);
1976 res = setup_fbuffer(fh, fb->base, &zoran_formats[i], fb->fmt.width,
1977 fb->fmt.height, fb->fmt.bytesperline);
1978 mutex_unlock(&zr->resource_lock);
1979
1980 return res;
1981}
1982
1983static int zoran_overlay(struct file *file, void *__fh, unsigned int on)
1984{
1985 struct zoran_fh *fh = __fh;
1986 struct zoran *zr = fh->zr;
1987 int res;
1988
1989 mutex_lock(&zr->resource_lock);
1990 res = setup_overlay(fh, on);
1991 mutex_unlock(&zr->resource_lock);
1992
1993 return res;
1994}
1995
1996static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type);
1997
1998static int zoran_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *req)
1999{
2000 struct zoran_fh *fh = __fh;
2001 struct zoran *zr = fh->zr;
2002 int res = 0;
2003
2004 if (req->memory != V4L2_MEMORY_MMAP) {
2005 dprintk(2,
2006 KERN_ERR
2007 "%s: only MEMORY_MMAP capture is supported, not %d\n",
2008 ZR_DEVNAME(zr), req->memory);
2009 return -EINVAL;
2010 }
2011
2012 if (req->count == 0)
2013 return zoran_streamoff(file, fh, req->type);
2014
2015 mutex_lock(&zr->resource_lock);
2016 if (fh->buffers.allocated) {
2017 dprintk(2,
2018 KERN_ERR
2019 "%s: VIDIOC_REQBUFS - buffers already allocated\n",
2020 ZR_DEVNAME(zr));
2021 res = -EBUSY;
2022 goto v4l2reqbuf_unlock_and_return;
2023 }
2024
2025 if (fh->map_mode == ZORAN_MAP_MODE_RAW &&
2026 req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2027
2028 if (req->count < 2)
2029 req->count = 2;
2030 if (req->count > v4l_nbufs)
2031 req->count = v4l_nbufs;
2032
2033
2034 map_mode_raw(fh);
2035 fh->buffers.num_buffers = req->count;
2036
2037 if (v4l_fbuffer_alloc(fh)) {
2038 res = -ENOMEM;
2039 goto v4l2reqbuf_unlock_and_return;
2040 }
2041 } else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC ||
2042 fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
2043
2044 if (req->count < 4)
2045 req->count = 4;
2046 if (req->count > jpg_nbufs)
2047 req->count = jpg_nbufs;
2048
2049
2050 map_mode_jpg(fh, req->type == V4L2_BUF_TYPE_VIDEO_OUTPUT);
2051 fh->buffers.num_buffers = req->count;
2052 fh->buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
2053
2054 if (jpg_fbuffer_alloc(fh)) {
2055 res = -ENOMEM;
2056 goto v4l2reqbuf_unlock_and_return;
2057 }
2058 } else {
2059 dprintk(1,
2060 KERN_ERR
2061 "%s: VIDIOC_REQBUFS - unknown type %d\n",
2062 ZR_DEVNAME(zr), req->type);
2063 res = -EINVAL;
2064 goto v4l2reqbuf_unlock_and_return;
2065 }
2066v4l2reqbuf_unlock_and_return:
2067 mutex_unlock(&zr->resource_lock);
2068
2069 return res;
2070}
2071
2072static int zoran_querybuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
2073{
2074 struct zoran_fh *fh = __fh;
2075 struct zoran *zr = fh->zr;
2076 int res;
2077
2078 mutex_lock(&zr->resource_lock);
2079 res = zoran_v4l2_buffer_status(fh, buf, buf->index);
2080 mutex_unlock(&zr->resource_lock);
2081
2082 return res;
2083}
2084
2085static int zoran_qbuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
2086{
2087 struct zoran_fh *fh = __fh;
2088 struct zoran *zr = fh->zr;
2089 int res = 0, codec_mode, buf_type;
2090
2091 mutex_lock(&zr->resource_lock);
2092
2093 switch (fh->map_mode) {
2094 case ZORAN_MAP_MODE_RAW:
2095 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2096 dprintk(1, KERN_ERR
2097 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2098 ZR_DEVNAME(zr), buf->type, fh->map_mode);
2099 res = -EINVAL;
2100 goto qbuf_unlock_and_return;
2101 }
2102
2103 res = zoran_v4l_queue_frame(fh, buf->index);
2104 if (res)
2105 goto qbuf_unlock_and_return;
2106 if (!zr->v4l_memgrab_active && fh->buffers.active == ZORAN_LOCKED)
2107 zr36057_set_memgrab(zr, 1);
2108 break;
2109
2110 case ZORAN_MAP_MODE_JPG_REC:
2111 case ZORAN_MAP_MODE_JPG_PLAY:
2112 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
2113 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2114 codec_mode = BUZ_MODE_MOTION_DECOMPRESS;
2115 } else {
2116 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2117 codec_mode = BUZ_MODE_MOTION_COMPRESS;
2118 }
2119
2120 if (buf->type != buf_type) {
2121 dprintk(1, KERN_ERR
2122 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2123 ZR_DEVNAME(zr), buf->type, fh->map_mode);
2124 res = -EINVAL;
2125 goto qbuf_unlock_and_return;
2126 }
2127
2128 res = zoran_jpg_queue_frame(fh, buf->index, codec_mode);
2129 if (res != 0)
2130 goto qbuf_unlock_and_return;
2131 if (zr->codec_mode == BUZ_MODE_IDLE &&
2132 fh->buffers.active == ZORAN_LOCKED)
2133 zr36057_enable_jpg(zr, codec_mode);
2134
2135 break;
2136
2137 default:
2138 dprintk(1, KERN_ERR
2139 "%s: VIDIOC_QBUF - unsupported type %d\n",
2140 ZR_DEVNAME(zr), buf->type);
2141 res = -EINVAL;
2142 break;
2143 }
2144qbuf_unlock_and_return:
2145 mutex_unlock(&zr->resource_lock);
2146
2147 return res;
2148}
2149
2150static int zoran_dqbuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
2151{
2152 struct zoran_fh *fh = __fh;
2153 struct zoran *zr = fh->zr;
2154 int res = 0, buf_type, num = -1;
2155
2156 mutex_lock(&zr->resource_lock);
2157
2158 switch (fh->map_mode) {
2159 case ZORAN_MAP_MODE_RAW:
2160 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2161 dprintk(1, KERN_ERR
2162 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2163 ZR_DEVNAME(zr), buf->type, fh->map_mode);
2164 res = -EINVAL;
2165 goto dqbuf_unlock_and_return;
2166 }
2167
2168 num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
2169 if (file->f_flags & O_NONBLOCK &&
2170 zr->v4l_buffers.buffer[num].state != BUZ_STATE_DONE) {
2171 res = -EAGAIN;
2172 goto dqbuf_unlock_and_return;
2173 }
2174 res = v4l_sync(fh, num);
2175 if (res)
2176 goto dqbuf_unlock_and_return;
2177 zr->v4l_sync_tail++;
2178 res = zoran_v4l2_buffer_status(fh, buf, num);
2179 break;
2180
2181 case ZORAN_MAP_MODE_JPG_REC:
2182 case ZORAN_MAP_MODE_JPG_PLAY:
2183 {
2184 struct zoran_sync bs;
2185
2186 if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY)
2187 buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2188 else
2189 buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2190
2191 if (buf->type != buf_type) {
2192 dprintk(1, KERN_ERR
2193 "%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2194 ZR_DEVNAME(zr), buf->type, fh->map_mode);
2195 res = -EINVAL;
2196 goto dqbuf_unlock_and_return;
2197 }
2198
2199 num = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
2200
2201 if (file->f_flags & O_NONBLOCK &&
2202 zr->jpg_buffers.buffer[num].state != BUZ_STATE_DONE) {
2203 res = -EAGAIN;
2204 goto dqbuf_unlock_and_return;
2205 }
2206 bs.frame = 0;
2207 res = jpg_sync(fh, &bs);
2208 if (res)
2209 goto dqbuf_unlock_and_return;
2210 res = zoran_v4l2_buffer_status(fh, buf, bs.frame);
2211 break;
2212 }
2213
2214 default:
2215 dprintk(1, KERN_ERR
2216 "%s: VIDIOC_DQBUF - unsupported type %d\n",
2217 ZR_DEVNAME(zr), buf->type);
2218 res = -EINVAL;
2219 break;
2220 }
2221dqbuf_unlock_and_return:
2222 mutex_unlock(&zr->resource_lock);
2223
2224 return res;
2225}
2226
2227static int zoran_streamon(struct file *file, void *__fh, enum v4l2_buf_type type)
2228{
2229 struct zoran_fh *fh = __fh;
2230 struct zoran *zr = fh->zr;
2231 int res = 0;
2232
2233 mutex_lock(&zr->resource_lock);
2234
2235 switch (fh->map_mode) {
2236 case ZORAN_MAP_MODE_RAW:
2237 if (zr->v4l_buffers.active != ZORAN_ACTIVE ||
2238 fh->buffers.active != ZORAN_ACTIVE) {
2239 res = -EBUSY;
2240 goto strmon_unlock_and_return;
2241 }
2242
2243 zr->v4l_buffers.active = fh->buffers.active = ZORAN_LOCKED;
2244 zr->v4l_settings = fh->v4l_settings;
2245
2246 zr->v4l_sync_tail = zr->v4l_pend_tail;
2247 if (!zr->v4l_memgrab_active &&
2248 zr->v4l_pend_head != zr->v4l_pend_tail) {
2249 zr36057_set_memgrab(zr, 1);
2250 }
2251 break;
2252
2253 case ZORAN_MAP_MODE_JPG_REC:
2254 case ZORAN_MAP_MODE_JPG_PLAY:
2255
2256 if (zr->jpg_buffers.active != ZORAN_ACTIVE ||
2257 fh->buffers.active != ZORAN_ACTIVE) {
2258 res = -EBUSY;
2259 goto strmon_unlock_and_return;
2260 }
2261
2262 zr->jpg_buffers.active = fh->buffers.active = ZORAN_LOCKED;
2263
2264 if (zr->jpg_que_head != zr->jpg_que_tail) {
2265
2266 jpeg_start(zr);
2267 }
2268 break;
2269
2270 default:
2271 dprintk(1,
2272 KERN_ERR
2273 "%s: VIDIOC_STREAMON - invalid map mode %d\n",
2274 ZR_DEVNAME(zr), fh->map_mode);
2275 res = -EINVAL;
2276 break;
2277 }
2278strmon_unlock_and_return:
2279 mutex_unlock(&zr->resource_lock);
2280
2281 return res;
2282}
2283
2284static int zoran_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type)
2285{
2286 struct zoran_fh *fh = __fh;
2287 struct zoran *zr = fh->zr;
2288 int i, res = 0;
2289 unsigned long flags;
2290
2291 mutex_lock(&zr->resource_lock);
2292
2293 switch (fh->map_mode) {
2294 case ZORAN_MAP_MODE_RAW:
2295 if (fh->buffers.active == ZORAN_FREE &&
2296 zr->v4l_buffers.active != ZORAN_FREE) {
2297 res = -EPERM;
2298 goto strmoff_unlock_and_return;
2299 }
2300 if (zr->v4l_buffers.active == ZORAN_FREE)
2301 goto strmoff_unlock_and_return;
2302
2303 spin_lock_irqsave(&zr->spinlock, flags);
2304
2305 if (zr->v4l_memgrab_active) {
2306
2307 zr36057_set_memgrab(zr, 0);
2308 }
2309
2310 for (i = 0; i < fh->buffers.num_buffers; i++)
2311 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;
2312 fh->buffers = zr->v4l_buffers;
2313
2314 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE;
2315
2316 zr->v4l_grab_seq = 0;
2317 zr->v4l_pend_head = zr->v4l_pend_tail = 0;
2318 zr->v4l_sync_tail = 0;
2319
2320 spin_unlock_irqrestore(&zr->spinlock, flags);
2321
2322 break;
2323
2324 case ZORAN_MAP_MODE_JPG_REC:
2325 case ZORAN_MAP_MODE_JPG_PLAY:
2326 if (fh->buffers.active == ZORAN_FREE &&
2327 zr->jpg_buffers.active != ZORAN_FREE) {
2328 res = -EPERM;
2329 goto strmoff_unlock_and_return;
2330 }
2331 if (zr->jpg_buffers.active == ZORAN_FREE)
2332 goto strmoff_unlock_and_return;
2333
2334 res = jpg_qbuf(fh, -1,
2335 (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?
2336 BUZ_MODE_MOTION_COMPRESS :
2337 BUZ_MODE_MOTION_DECOMPRESS);
2338 if (res)
2339 goto strmoff_unlock_and_return;
2340 break;
2341 default:
2342 dprintk(1, KERN_ERR
2343 "%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
2344 ZR_DEVNAME(zr), fh->map_mode);
2345 res = -EINVAL;
2346 break;
2347 }
2348strmoff_unlock_and_return:
2349 mutex_unlock(&zr->resource_lock);
2350
2351 return res;
2352}
2353
2354static int zoran_queryctrl(struct file *file, void *__fh,
2355 struct v4l2_queryctrl *ctrl)
2356{
2357 struct zoran_fh *fh = __fh;
2358 struct zoran *zr = fh->zr;
2359
2360
2361 if (ctrl->id < V4L2_CID_BRIGHTNESS ||
2362 ctrl->id > V4L2_CID_HUE)
2363 return -EINVAL;
2364
2365 decoder_call(zr, core, queryctrl, ctrl);
2366
2367 return 0;
2368}
2369
2370static int zoran_g_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl)
2371{
2372 struct zoran_fh *fh = __fh;
2373 struct zoran *zr = fh->zr;
2374
2375
2376 if (ctrl->id < V4L2_CID_BRIGHTNESS ||
2377 ctrl->id > V4L2_CID_HUE)
2378 return -EINVAL;
2379
2380 mutex_lock(&zr->resource_lock);
2381 decoder_call(zr, core, g_ctrl, ctrl);
2382 mutex_unlock(&zr->resource_lock);
2383
2384 return 0;
2385}
2386
2387static int zoran_s_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl)
2388{
2389 struct zoran_fh *fh = __fh;
2390 struct zoran *zr = fh->zr;
2391
2392
2393 if (ctrl->id < V4L2_CID_BRIGHTNESS ||
2394 ctrl->id > V4L2_CID_HUE)
2395 return -EINVAL;
2396
2397 mutex_lock(&zr->resource_lock);
2398 decoder_call(zr, core, s_ctrl, ctrl);
2399 mutex_unlock(&zr->resource_lock);
2400
2401 return 0;
2402}
2403
2404static int zoran_g_std(struct file *file, void *__fh, v4l2_std_id *std)
2405{
2406 struct zoran_fh *fh = __fh;
2407 struct zoran *zr = fh->zr;
2408
2409 mutex_lock(&zr->resource_lock);
2410 *std = zr->norm;
2411 mutex_unlock(&zr->resource_lock);
2412 return 0;
2413}
2414
2415static int zoran_s_std(struct file *file, void *__fh, v4l2_std_id std)
2416{
2417 struct zoran_fh *fh = __fh;
2418 struct zoran *zr = fh->zr;
2419 int res = 0;
2420
2421 mutex_lock(&zr->resource_lock);
2422 res = zoran_set_norm(zr, std);
2423 if (res)
2424 goto sstd_unlock_and_return;
2425
2426 res = wait_grab_pending(zr);
2427sstd_unlock_and_return:
2428 mutex_unlock(&zr->resource_lock);
2429 return res;
2430}
2431
2432static int zoran_enum_input(struct file *file, void *__fh,
2433 struct v4l2_input *inp)
2434{
2435 struct zoran_fh *fh = __fh;
2436 struct zoran *zr = fh->zr;
2437
2438 if (inp->index >= zr->card.inputs)
2439 return -EINVAL;
2440
2441 strncpy(inp->name, zr->card.input[inp->index].name,
2442 sizeof(inp->name) - 1);
2443 inp->type = V4L2_INPUT_TYPE_CAMERA;
2444 inp->std = V4L2_STD_ALL;
2445
2446
2447 mutex_lock(&zr->resource_lock);
2448 decoder_call(zr, video, g_input_status, &inp->status);
2449 mutex_unlock(&zr->resource_lock);
2450 return 0;
2451}
2452
2453static int zoran_g_input(struct file *file, void *__fh, unsigned int *input)
2454{
2455 struct zoran_fh *fh = __fh;
2456 struct zoran *zr = fh->zr;
2457
2458 mutex_lock(&zr->resource_lock);
2459 *input = zr->input;
2460 mutex_unlock(&zr->resource_lock);
2461
2462 return 0;
2463}
2464
2465static int zoran_s_input(struct file *file, void *__fh, unsigned int input)
2466{
2467 struct zoran_fh *fh = __fh;
2468 struct zoran *zr = fh->zr;
2469 int res;
2470
2471 mutex_lock(&zr->resource_lock);
2472 res = zoran_set_input(zr, input);
2473 if (res)
2474 goto sinput_unlock_and_return;
2475
2476
2477 res = wait_grab_pending(zr);
2478sinput_unlock_and_return:
2479 mutex_unlock(&zr->resource_lock);
2480 return res;
2481}
2482
2483static int zoran_enum_output(struct file *file, void *__fh,
2484 struct v4l2_output *outp)
2485{
2486 if (outp->index != 0)
2487 return -EINVAL;
2488
2489 outp->index = 0;
2490 outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY;
2491 strncpy(outp->name, "Autodetect", sizeof(outp->name)-1);
2492
2493 return 0;
2494}
2495
2496static int zoran_g_output(struct file *file, void *__fh, unsigned int *output)
2497{
2498 *output = 0;
2499
2500 return 0;
2501}
2502
2503static int zoran_s_output(struct file *file, void *__fh, unsigned int output)
2504{
2505 if (output != 0)
2506 return -EINVAL;
2507
2508 return 0;
2509}
2510
2511
2512static int zoran_cropcap(struct file *file, void *__fh,
2513 struct v4l2_cropcap *cropcap)
2514{
2515 struct zoran_fh *fh = __fh;
2516 struct zoran *zr = fh->zr;
2517 int type = cropcap->type, res = 0;
2518
2519 memset(cropcap, 0, sizeof(*cropcap));
2520 cropcap->type = type;
2521
2522 mutex_lock(&zr->resource_lock);
2523
2524 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2525 (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2526 fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2527 dprintk(1, KERN_ERR
2528 "%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",
2529 ZR_DEVNAME(zr));
2530 res = -EINVAL;
2531 goto cropcap_unlock_and_return;
2532 }
2533
2534 cropcap->bounds.top = cropcap->bounds.left = 0;
2535 cropcap->bounds.width = BUZ_MAX_WIDTH;
2536 cropcap->bounds.height = BUZ_MAX_HEIGHT;
2537 cropcap->defrect.top = cropcap->defrect.left = 0;
2538 cropcap->defrect.width = BUZ_MIN_WIDTH;
2539 cropcap->defrect.height = BUZ_MIN_HEIGHT;
2540cropcap_unlock_and_return:
2541 mutex_unlock(&zr->resource_lock);
2542 return res;
2543}
2544
2545static int zoran_g_crop(struct file *file, void *__fh, struct v4l2_crop *crop)
2546{
2547 struct zoran_fh *fh = __fh;
2548 struct zoran *zr = fh->zr;
2549 int type = crop->type, res = 0;
2550
2551 memset(crop, 0, sizeof(*crop));
2552 crop->type = type;
2553
2554 mutex_lock(&zr->resource_lock);
2555
2556 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2557 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2558 fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2559 dprintk(1,
2560 KERN_ERR
2561 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2562 ZR_DEVNAME(zr));
2563 res = -EINVAL;
2564 goto gcrop_unlock_and_return;
2565 }
2566
2567 crop->c.top = fh->jpg_settings.img_y;
2568 crop->c.left = fh->jpg_settings.img_x;
2569 crop->c.width = fh->jpg_settings.img_width;
2570 crop->c.height = fh->jpg_settings.img_height;
2571
2572gcrop_unlock_and_return:
2573 mutex_unlock(&zr->resource_lock);
2574
2575 return res;
2576}
2577
2578static int zoran_s_crop(struct file *file, void *__fh, const struct v4l2_crop *crop)
2579{
2580 struct zoran_fh *fh = __fh;
2581 struct zoran *zr = fh->zr;
2582 int res = 0;
2583 struct zoran_jpg_settings settings;
2584
2585 settings = fh->jpg_settings;
2586
2587 mutex_lock(&zr->resource_lock);
2588
2589 if (fh->buffers.allocated) {
2590 dprintk(1, KERN_ERR
2591 "%s: VIDIOC_S_CROP - cannot change settings while active\n",
2592 ZR_DEVNAME(zr));
2593 res = -EBUSY;
2594 goto scrop_unlock_and_return;
2595 }
2596
2597 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2598 (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2599 fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2600 dprintk(1, KERN_ERR
2601 "%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2602 ZR_DEVNAME(zr));
2603 res = -EINVAL;
2604 goto scrop_unlock_and_return;
2605 }
2606
2607
2608 settings.img_x = crop->c.left;
2609 settings.img_y = crop->c.top;
2610 settings.img_width = crop->c.width;
2611 settings.img_height = crop->c.height;
2612
2613
2614 res = zoran_check_jpg_settings(zr, &settings, 0);
2615 if (res)
2616 goto scrop_unlock_and_return;
2617
2618
2619 fh->jpg_settings = settings;
2620
2621scrop_unlock_and_return:
2622 mutex_unlock(&zr->resource_lock);
2623 return res;
2624}
2625
2626static int zoran_g_jpegcomp(struct file *file, void *__fh,
2627 struct v4l2_jpegcompression *params)
2628{
2629 struct zoran_fh *fh = __fh;
2630 struct zoran *zr = fh->zr;
2631 memset(params, 0, sizeof(*params));
2632
2633 mutex_lock(&zr->resource_lock);
2634
2635 params->quality = fh->jpg_settings.jpg_comp.quality;
2636 params->APPn = fh->jpg_settings.jpg_comp.APPn;
2637 memcpy(params->APP_data,
2638 fh->jpg_settings.jpg_comp.APP_data,
2639 fh->jpg_settings.jpg_comp.APP_len);
2640 params->APP_len = fh->jpg_settings.jpg_comp.APP_len;
2641 memcpy(params->COM_data,
2642 fh->jpg_settings.jpg_comp.COM_data,
2643 fh->jpg_settings.jpg_comp.COM_len);
2644 params->COM_len = fh->jpg_settings.jpg_comp.COM_len;
2645 params->jpeg_markers =
2646 fh->jpg_settings.jpg_comp.jpeg_markers;
2647
2648 mutex_unlock(&zr->resource_lock);
2649
2650 return 0;
2651}
2652
2653static int zoran_s_jpegcomp(struct file *file, void *__fh,
2654 const struct v4l2_jpegcompression *params)
2655{
2656 struct zoran_fh *fh = __fh;
2657 struct zoran *zr = fh->zr;
2658 int res = 0;
2659 struct zoran_jpg_settings settings;
2660
2661 settings = fh->jpg_settings;
2662
2663 settings.jpg_comp = *params;
2664
2665 mutex_lock(&zr->resource_lock);
2666
2667 if (fh->buffers.active != ZORAN_FREE) {
2668 dprintk(1, KERN_WARNING
2669 "%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
2670 ZR_DEVNAME(zr));
2671 res = -EBUSY;
2672 goto sjpegc_unlock_and_return;
2673 }
2674
2675 res = zoran_check_jpg_settings(zr, &settings, 0);
2676 if (res)
2677 goto sjpegc_unlock_and_return;
2678 if (!fh->buffers.allocated)
2679 fh->buffers.buffer_size =
2680 zoran_v4l2_calc_bufsize(&fh->jpg_settings);
2681 fh->jpg_settings.jpg_comp = settings.jpg_comp;
2682sjpegc_unlock_and_return:
2683 mutex_unlock(&zr->resource_lock);
2684
2685 return res;
2686}
2687
2688static unsigned int
2689zoran_poll (struct file *file,
2690 poll_table *wait)
2691{
2692 struct zoran_fh *fh = file->private_data;
2693 struct zoran *zr = fh->zr;
2694 int res = 0, frame;
2695 unsigned long flags;
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705 mutex_lock(&zr->resource_lock);
2706
2707 switch (fh->map_mode) {
2708 case ZORAN_MAP_MODE_RAW:
2709 poll_wait(file, &zr->v4l_capq, wait);
2710 frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
2711
2712 spin_lock_irqsave(&zr->spinlock, flags);
2713 dprintk(3,
2714 KERN_DEBUG
2715 "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
2716 ZR_DEVNAME(zr), __func__,
2717 "FAL"[fh->buffers.active], zr->v4l_sync_tail,
2718 "UPMD"[zr->v4l_buffers.buffer[frame].state],
2719 zr->v4l_pend_tail, zr->v4l_pend_head);
2720
2721 if (fh->buffers.active != ZORAN_FREE &&
2722
2723 zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE)
2724 res = POLLIN | POLLRDNORM;
2725 spin_unlock_irqrestore(&zr->spinlock, flags);
2726
2727 break;
2728
2729 case ZORAN_MAP_MODE_JPG_REC:
2730 case ZORAN_MAP_MODE_JPG_PLAY:
2731 poll_wait(file, &zr->jpg_capq, wait);
2732 frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
2733
2734 spin_lock_irqsave(&zr->spinlock, flags);
2735 dprintk(3,
2736 KERN_DEBUG
2737 "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
2738 ZR_DEVNAME(zr), __func__,
2739 "FAL"[fh->buffers.active], zr->jpg_que_tail,
2740 "UPMD"[zr->jpg_buffers.buffer[frame].state],
2741 zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head);
2742 if (fh->buffers.active != ZORAN_FREE &&
2743 zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) {
2744 if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC)
2745 res = POLLIN | POLLRDNORM;
2746 else
2747 res = POLLOUT | POLLWRNORM;
2748 }
2749 spin_unlock_irqrestore(&zr->spinlock, flags);
2750
2751 break;
2752
2753 default:
2754 dprintk(1,
2755 KERN_ERR
2756 "%s: %s - internal error, unknown map_mode=%d\n",
2757 ZR_DEVNAME(zr), __func__, fh->map_mode);
2758 res = POLLNVAL;
2759 }
2760
2761 mutex_unlock(&zr->resource_lock);
2762
2763 return res;
2764}
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779static void
2780zoran_vm_open (struct vm_area_struct *vma)
2781{
2782 struct zoran_mapping *map = vma->vm_private_data;
2783 atomic_inc(&map->count);
2784}
2785
2786static void
2787zoran_vm_close (struct vm_area_struct *vma)
2788{
2789 struct zoran_mapping *map = vma->vm_private_data;
2790 struct zoran_fh *fh = map->fh;
2791 struct zoran *zr = fh->zr;
2792 int i;
2793
2794 if (!atomic_dec_and_mutex_lock(&map->count, &zr->resource_lock))
2795 return;
2796
2797 dprintk(3, KERN_INFO "%s: %s - munmap(%s)\n", ZR_DEVNAME(zr),
2798 __func__, mode_name(fh->map_mode));
2799
2800 for (i = 0; i < fh->buffers.num_buffers; i++) {
2801 if (fh->buffers.buffer[i].map == map)
2802 fh->buffers.buffer[i].map = NULL;
2803 }
2804 kfree(map);
2805
2806
2807 for (i = 0; i < fh->buffers.num_buffers; i++) {
2808 if (fh->buffers.buffer[i].map) {
2809 mutex_unlock(&zr->resource_lock);
2810 return;
2811 }
2812 }
2813
2814 dprintk(3, KERN_INFO "%s: %s - free %s buffers\n", ZR_DEVNAME(zr),
2815 __func__, mode_name(fh->map_mode));
2816
2817
2818 if (fh->map_mode == ZORAN_MAP_MODE_RAW) {
2819 if (fh->buffers.active != ZORAN_FREE) {
2820 unsigned long flags;
2821
2822 spin_lock_irqsave(&zr->spinlock, flags);
2823 zr36057_set_memgrab(zr, 0);
2824 zr->v4l_buffers.allocated = 0;
2825 zr->v4l_buffers.active = fh->buffers.active = ZORAN_FREE;
2826 spin_unlock_irqrestore(&zr->spinlock, flags);
2827 }
2828 v4l_fbuffer_free(fh);
2829 } else {
2830 if (fh->buffers.active != ZORAN_FREE) {
2831 jpg_qbuf(fh, -1, zr->codec_mode);
2832 zr->jpg_buffers.allocated = 0;
2833 zr->jpg_buffers.active = fh->buffers.active = ZORAN_FREE;
2834 }
2835 jpg_fbuffer_free(fh);
2836 }
2837
2838 mutex_unlock(&zr->resource_lock);
2839}
2840
2841static const struct vm_operations_struct zoran_vm_ops = {
2842 .open = zoran_vm_open,
2843 .close = zoran_vm_close,
2844};
2845
2846static int
2847zoran_mmap (struct file *file,
2848 struct vm_area_struct *vma)
2849{
2850 struct zoran_fh *fh = file->private_data;
2851 struct zoran *zr = fh->zr;
2852 unsigned long size = (vma->vm_end - vma->vm_start);
2853 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
2854 int i, j;
2855 unsigned long page, start = vma->vm_start, todo, pos, fraglen;
2856 int first, last;
2857 struct zoran_mapping *map;
2858 int res = 0;
2859
2860 dprintk(3,
2861 KERN_INFO "%s: %s(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
2862 ZR_DEVNAME(zr), __func__,
2863 mode_name(fh->map_mode), vma->vm_start, vma->vm_end, size);
2864
2865 if (!(vma->vm_flags & VM_SHARED) || !(vma->vm_flags & VM_READ) ||
2866 !(vma->vm_flags & VM_WRITE)) {
2867 dprintk(1,
2868 KERN_ERR
2869 "%s: %s - no MAP_SHARED/PROT_{READ,WRITE} given\n",
2870 ZR_DEVNAME(zr), __func__);
2871 return -EINVAL;
2872 }
2873
2874 mutex_lock(&zr->resource_lock);
2875
2876 if (!fh->buffers.allocated) {
2877 dprintk(1,
2878 KERN_ERR
2879 "%s: %s(%s) - buffers not yet allocated\n",
2880 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode));
2881 res = -ENOMEM;
2882 goto mmap_unlock_and_return;
2883 }
2884
2885 first = offset / fh->buffers.buffer_size;
2886 last = first - 1 + size / fh->buffers.buffer_size;
2887 if (offset % fh->buffers.buffer_size != 0 ||
2888 size % fh->buffers.buffer_size != 0 || first < 0 ||
2889 last < 0 || first >= fh->buffers.num_buffers ||
2890 last >= fh->buffers.buffer_size) {
2891 dprintk(1,
2892 KERN_ERR
2893 "%s: %s(%s) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
2894 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), offset, size,
2895 fh->buffers.buffer_size,
2896 fh->buffers.num_buffers);
2897 res = -EINVAL;
2898 goto mmap_unlock_and_return;
2899 }
2900
2901
2902 for (i = first; i <= last; i++) {
2903 if (fh->buffers.buffer[i].map) {
2904 dprintk(1,
2905 KERN_ERR
2906 "%s: %s(%s) - buffer %d already mapped\n",
2907 ZR_DEVNAME(zr), __func__, mode_name(fh->map_mode), i);
2908 res = -EBUSY;
2909 goto mmap_unlock_and_return;
2910 }
2911 }
2912
2913
2914 map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);
2915 if (!map) {
2916 res = -ENOMEM;
2917 goto mmap_unlock_and_return;
2918 }
2919 map->fh = fh;
2920 atomic_set(&map->count, 1);
2921
2922 vma->vm_ops = &zoran_vm_ops;
2923 vma->vm_flags |= VM_DONTEXPAND;
2924 vma->vm_private_data = map;
2925
2926 if (fh->map_mode == ZORAN_MAP_MODE_RAW) {
2927 for (i = first; i <= last; i++) {
2928 todo = size;
2929 if (todo > fh->buffers.buffer_size)
2930 todo = fh->buffers.buffer_size;
2931 page = fh->buffers.buffer[i].v4l.fbuffer_phys;
2932 if (remap_pfn_range(vma, start, page >> PAGE_SHIFT,
2933 todo, PAGE_SHARED)) {
2934 dprintk(1,
2935 KERN_ERR
2936 "%s: %s(V4L) - remap_pfn_range failed\n",
2937 ZR_DEVNAME(zr), __func__);
2938 res = -EAGAIN;
2939 goto mmap_unlock_and_return;
2940 }
2941 size -= todo;
2942 start += todo;
2943 fh->buffers.buffer[i].map = map;
2944 if (size == 0)
2945 break;
2946 }
2947 } else {
2948 for (i = first; i <= last; i++) {
2949 for (j = 0;
2950 j < fh->buffers.buffer_size / PAGE_SIZE;
2951 j++) {
2952 fraglen =
2953 (le32_to_cpu(fh->buffers.buffer[i].jpg.
2954 frag_tab[2 * j + 1]) & ~1) << 1;
2955 todo = size;
2956 if (todo > fraglen)
2957 todo = fraglen;
2958 pos =
2959 le32_to_cpu(fh->buffers.
2960 buffer[i].jpg.frag_tab[2 * j]);
2961
2962 page = virt_to_phys(bus_to_virt(pos))
2963 >> PAGE_SHIFT;
2964 if (remap_pfn_range(vma, start, page,
2965 todo, PAGE_SHARED)) {
2966 dprintk(1,
2967 KERN_ERR
2968 "%s: %s(V4L) - remap_pfn_range failed\n",
2969 ZR_DEVNAME(zr), __func__);
2970 res = -EAGAIN;
2971 goto mmap_unlock_and_return;
2972 }
2973 size -= todo;
2974 start += todo;
2975 if (size == 0)
2976 break;
2977 if (le32_to_cpu(fh->buffers.buffer[i].jpg.
2978 frag_tab[2 * j + 1]) & 1)
2979 break;
2980 }
2981 fh->buffers.buffer[i].map = map;
2982 if (size == 0)
2983 break;
2984
2985 }
2986 }
2987
2988mmap_unlock_and_return:
2989 mutex_unlock(&zr->resource_lock);
2990
2991 return res;
2992}
2993
2994static const struct v4l2_ioctl_ops zoran_ioctl_ops = {
2995 .vidioc_querycap = zoran_querycap,
2996 .vidioc_cropcap = zoran_cropcap,
2997 .vidioc_s_crop = zoran_s_crop,
2998 .vidioc_g_crop = zoran_g_crop,
2999 .vidioc_enum_input = zoran_enum_input,
3000 .vidioc_g_input = zoran_g_input,
3001 .vidioc_s_input = zoran_s_input,
3002 .vidioc_enum_output = zoran_enum_output,
3003 .vidioc_g_output = zoran_g_output,
3004 .vidioc_s_output = zoran_s_output,
3005 .vidioc_g_fbuf = zoran_g_fbuf,
3006 .vidioc_s_fbuf = zoran_s_fbuf,
3007 .vidioc_g_std = zoran_g_std,
3008 .vidioc_s_std = zoran_s_std,
3009 .vidioc_g_jpegcomp = zoran_g_jpegcomp,
3010 .vidioc_s_jpegcomp = zoran_s_jpegcomp,
3011 .vidioc_overlay = zoran_overlay,
3012 .vidioc_reqbufs = zoran_reqbufs,
3013 .vidioc_querybuf = zoran_querybuf,
3014 .vidioc_qbuf = zoran_qbuf,
3015 .vidioc_dqbuf = zoran_dqbuf,
3016 .vidioc_streamon = zoran_streamon,
3017 .vidioc_streamoff = zoran_streamoff,
3018 .vidioc_enum_fmt_vid_cap = zoran_enum_fmt_vid_cap,
3019 .vidioc_enum_fmt_vid_out = zoran_enum_fmt_vid_out,
3020 .vidioc_enum_fmt_vid_overlay = zoran_enum_fmt_vid_overlay,
3021 .vidioc_g_fmt_vid_cap = zoran_g_fmt_vid_cap,
3022 .vidioc_g_fmt_vid_out = zoran_g_fmt_vid_out,
3023 .vidioc_g_fmt_vid_overlay = zoran_g_fmt_vid_overlay,
3024 .vidioc_s_fmt_vid_cap = zoran_s_fmt_vid_cap,
3025 .vidioc_s_fmt_vid_out = zoran_s_fmt_vid_out,
3026 .vidioc_s_fmt_vid_overlay = zoran_s_fmt_vid_overlay,
3027 .vidioc_try_fmt_vid_cap = zoran_try_fmt_vid_cap,
3028 .vidioc_try_fmt_vid_out = zoran_try_fmt_vid_out,
3029 .vidioc_try_fmt_vid_overlay = zoran_try_fmt_vid_overlay,
3030 .vidioc_queryctrl = zoran_queryctrl,
3031 .vidioc_s_ctrl = zoran_s_ctrl,
3032 .vidioc_g_ctrl = zoran_g_ctrl,
3033};
3034
3035
3036static long zoran_ioctl(struct file *file, unsigned int cmd,
3037 unsigned long arg)
3038{
3039 struct zoran_fh *fh = file->private_data;
3040 struct zoran *zr = fh->zr;
3041 int ret;
3042
3043 mutex_lock(&zr->other_lock);
3044 ret = video_ioctl2(file, cmd, arg);
3045 mutex_unlock(&zr->other_lock);
3046
3047 return ret;
3048}
3049
3050static const struct v4l2_file_operations zoran_fops = {
3051 .owner = THIS_MODULE,
3052 .open = zoran_open,
3053 .release = zoran_close,
3054 .unlocked_ioctl = zoran_ioctl,
3055 .read = zoran_read,
3056 .write = zoran_write,
3057 .mmap = zoran_mmap,
3058 .poll = zoran_poll,
3059};
3060
3061struct video_device zoran_template = {
3062 .name = ZORAN_NAME,
3063 .fops = &zoran_fops,
3064 .ioctl_ops = &zoran_ioctl_ops,
3065 .release = &zoran_vdev_release,
3066 .tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
3067};
3068
3069