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