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