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