drivers/media/video/zoran/zoran_driver.c

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