drivers/media/video/buz.c

   1 #define MAX_KMALLOC_MEM (512*1024)
   2 /*
   3    buz - Iomega Buz driver version 1.0
   4
   5    Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de>
   6
   7    based on
   8
   9    buz.0.0.3 Copyright (C) 1998 Dave Perks <dperks@ibm.net>
  10
  11    and
  12
  13    bttv - Bt848 frame grabber driver
  14
  15    Copyright (C) 1996,97,98 Ralph  Metzler (rjkm@thp.uni-koeln.de)
  16    & Marcus Metzler (mocm@thp.uni-koeln.de)
  17
  18    This program is free software; you can redistribute it and/or modify
  19    it under the terms of the GNU General Public License as published by
  20    the Free Software Foundation; either version 2 of the License, or
  21    (at your option) any later version.
  22
  23    This program is distributed in the hope that it will be useful,
  24    but WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26    GNU General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program; if not, write to the Free Software
  30    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  */
  32
  33 #include <linux/module.h>
  34 #include <linux/delay.h>
  35 #include <linux/errno.h>
  36 #include <linux/fs.h>
  37 #include <linux/kernel.h>
  38 #include <linux/major.h>
  39 #include <linux/malloc.h>
  40 #include <linux/mm.h>
  41 #include <linux/pci.h>
  42 #include <linux/signal.h>
  43 #include <asm/io.h>
  44 #include <asm/pgtable.h>
  45 #include <asm/page.h>
  46 #include <linux/sched.h>
  47 #include <asm/segment.h>
  48 #include <linux/types.h>
  49 #include <linux/wrapper.h>
  50 #include <linux/spinlock.h>
  51 #include <linux/vmalloc.h>
  52
  53 #include <linux/videodev.h>
  54
  55 #include <linux/version.h>
  56 #include <asm/uaccess.h>
  57
  58 #include <linux/i2c-old.h>
  59 #include "buz.h"
  60 #include <linux/video_decoder.h>
  61 #include <linux/video_encoder.h>
  62
  63 #define IRQ_MASK ( ZR36057_ISR_GIRQ0 | /* ZR36057_ISR_GIRQ1 | ZR36057_ISR_CodRepIRQ | */ ZR36057_ISR_JPEGRepIRQ )
  64 #define GPIO_MASK 0xdf
  65
  66 /*
  67
  68  BUZ
  69
  70    GPIO0 = 1, take board out of reset
  71    GPIO1 = 1, take JPEG codec out of sleep mode
  72    GPIO3 = 1, deassert FRAME# to 36060
  73
  74
  75    GIRQ0 signals a vertical sync of the video signal
  76    GIRQ1 signals that ZR36060's DATERR# line is asserted.
  77
  78    SAA7111A
  79
  80    In their infinite wisdom, the Iomega engineers decided to
  81    use the same input line for composite and S-Video Color,
  82    although there are two entries not connected at all!
  83    Through this ingenious strike, it is not possible to
  84    keep two running video sources connected at the same time
  85    to Composite and S-VHS input!
  86
  87    mode 0 - N/C
  88    mode 1 - S-Video Y
  89    mode 2 - noise or something I don't know
  90    mode 3 - Composite and S-Video C
  91    mode 4 - N/C
  92    mode 5 - S-Video (gain C independently selectable of gain Y)
  93    mode 6 - N/C
  94    mode 7 - S-Video (gain C adapted to gain Y)
  95  */
  96
  97 #define MAJOR_VERSION 1         /* driver major version */
  98 #define MINOR_VERSION 0         /* driver minor version */
  99
 100 #define BUZ_NAME      "Iomega BUZ V-1.0"        /* name of the driver */
 101
 102 #define DEBUG(x)                /* Debug driver */
 103 #define IDEBUG(x)               /* Debug interrupt handler */
 104 #define IOCTL_DEBUG(x)
 105
 106
 107 /* The parameters for this driver */
 108
 109 /*
 110    The video mem address of the video card.
 111    The driver has a little database for some videocards
 112    to determine it from there. If your video card is not in there
 113    you have either to give it to the driver as a parameter
 114    or set in in a VIDIOCSFBUF ioctl
 115  */
 116
 117 static unsigned long vidmem = 0;        /* Video memory base address */
 118
 119 /* Special purposes only: */
 120
 121 static int triton = 0;          /* 0=no, 1=yes */
 122 static int natoma = 0;          /* 0=no, 1=yes */
 123
 124 /*
 125    Number and size of grab buffers for Video 4 Linux
 126    The vast majority of applications should not need more than 2,
 127    the very popular BTTV driver actually does ONLY have 2.
 128    Time sensitive applications might need more, the maximum
 129    is VIDEO_MAX_FRAME (defined in <linux/videodev.h>).
 130
 131    The size is set so that the maximum possible request
 132    can be satisfied. Decrease  it, if bigphys_area alloc'd
 133    memory is low. If you don't have the bigphys_area patch,
 134    set it to 128 KB. Will you allow only to grab small
 135    images with V4L, but that's better than nothing.
 136
 137    v4l_bufsize has to be given in KB !
 138
 139  */
 140
 141 static int v4l_nbufs = 2;
 142 static int v4l_bufsize = 128;   /* Everybody should be able to work with this setting */
 143
 144 /*
 145    Default input and video norm at startup of the driver.
 146  */
 147
 148 static int default_input = 0;   /* 0=Composite, 1=S-VHS */
 149 static int default_norm = 0;    /* 0=PAL, 1=NTSC */
 150
 151 MODULE_PARM(vidmem, "i");
 152 MODULE_PARM(triton, "i");
 153 MODULE_PARM(natoma, "i");
 154 MODULE_PARM(v4l_nbufs, "i");
 155 MODULE_PARM(v4l_bufsize, "i");
 156 MODULE_PARM(default_input, "i");
 157 MODULE_PARM(default_norm, "i");
 158
 159 /* Anybody who uses more than four? */
 160 #define BUZ_MAX 4
 161
 162 static int zoran_num;           /* number of Buzs in use */
 163 static struct zoran zoran[BUZ_MAX];
 164
 165 /* forward references */
 166
 167 static void v4l_fbuffer_free(struct zoran *zr);
 168 static void jpg_fbuffer_free(struct zoran *zr);
 169 static void zoran_feed_stat_com(struct zoran *zr);
 170
 171
 172
 173 /*
 174  *   Allocate the V4L grab buffers
 175  *
 176  *   These have to be pysically contiguous.
 177  *   If v4l_bufsize <= MAX_KMALLOC_MEM we use kmalloc
 178  */
 179
 180 static int v4l_fbuffer_alloc(struct zoran *zr)
 181 {
 182         int i, off;
 183         unsigned char *mem;
 184
 185         for (i = 0; i < v4l_nbufs; i++) {
 186                 if (zr->v4l_gbuf[i].fbuffer)
 187                         printk(KERN_WARNING "%s: v4l_fbuffer_alloc: buffer %d allready allocated ?\n", zr->name, i);
 188
 189                 if (v4l_bufsize <= MAX_KMALLOC_MEM) {
 190                         /* Use kmalloc */
 191
 192                         mem = (unsigned char *) kmalloc(v4l_bufsize, GFP_KERNEL);
 193                         if (mem == 0) {
 194                                 printk(KERN_ERR "%s: kmalloc for V4L bufs failed\n", zr->name);
 195                                 v4l_fbuffer_free(zr);
 196                                 return -ENOBUFS;
 197                         }
 198                         zr->v4l_gbuf[i].fbuffer = mem;
 199                         zr->v4l_gbuf[i].fbuffer_phys = virt_to_phys(mem);
 200                         zr->v4l_gbuf[i].fbuffer_bus = virt_to_bus(mem);
 201                         for (off = 0; off < v4l_bufsize; off += PAGE_SIZE)
 202                                 mem_map_reserve(virt_to_page(mem + off));
 203                         DEBUG(printk(BUZ_INFO ": V4L frame %d mem 0x%x (bus: 0x%x=%d)\n", i, mem, virt_to_bus(mem), virt_to_bus(mem)));
 204                 } else {
 205                         v4l_fbuffer_free(zr);
 206                         return -ENOBUFS;
 207                 }
 208         }
 209
 210         return 0;
 211 }
 212
 213 /* free the V4L grab buffers */
 214 static void v4l_fbuffer_free(struct zoran *zr)
 215 {
 216         int i, off;
 217         unsigned char *mem;
 218
 219         for (i = 0; i < v4l_nbufs; i++) {
 220                 if (!zr->v4l_gbuf[i].fbuffer)
 221                         continue;
 222
 223                 mem = zr->v4l_gbuf[i].fbuffer;
 224                 for (off = 0; off < v4l_bufsize; off += PAGE_SIZE)
 225                         mem_map_unreserve(virt_to_page(mem + off));
 226                 kfree((void *) zr->v4l_gbuf[i].fbuffer);
 227                 zr->v4l_gbuf[i].fbuffer = NULL;
 228         }
 229 }
 230
 231 /*
 232  *   Allocate the MJPEG grab buffers.
 233  *
 234  *   If the requested buffer size is smaller than MAX_KMALLOC_MEM,
 235  *   kmalloc is used to request a physically contiguous area,
 236  *   else we allocate the memory in framgents with get_free_page.
 237  *
 238  *   If a Natoma chipset is present and this is a revision 1 zr36057,
 239  *   each MJPEG buffer needs to be physically contiguous.
 240  *   (RJ: This statement is from Dave Perks' original driver,
 241  *   I could never check it because I have a zr36067)
 242  *   The driver cares about this because it reduces the buffer
 243  *   size to MAX_KMALLOC_MEM in that case (which forces contiguous allocation).
 244  *
 245  *   RJ: The contents grab buffers needs never be accessed in the driver.
 246  *       Therefore there is no need to allocate them with vmalloc in order
 247  *       to get a contiguous virtual memory space.
 248  *       I don't understand why many other drivers first allocate them with
 249  *       vmalloc (which uses internally also get_free_page, but delivers you
 250  *       virtual addresses) and then again have to make a lot of efforts
 251  *       to get the physical address.
 252  *
 253  */
 254
 255 static int jpg_fbuffer_alloc(struct zoran *zr)
 256 {
 257         int i, j, off, alloc_contig;
 258         unsigned long mem;
 259
 260         /* Decide if we should alloc contiguous or fragmented memory */
 261         /* This has to be identical in jpg_fbuffer_alloc and jpg_fbuffer_free */
 262
 263         alloc_contig = (zr->jpg_bufsize < MAX_KMALLOC_MEM);
 264
 265         for (i = 0; i < zr->jpg_nbufs; i++) {
 266                 if (zr->jpg_gbuf[i].frag_tab)
 267                         printk(KERN_WARNING "%s: jpg_fbuffer_alloc: buffer %d allready allocated ???\n", zr->name, i);
 268
 269                 /* Allocate fragment table for this buffer */
 270
 271                 mem = get_free_page(GFP_KERNEL);
 272                 if (mem == 0) {
 273                         printk(KERN_ERR "%s: jpg_fbuffer_alloc: get_free_page (frag_tab) failed for buffer %d\n", zr->name, i);
 274                         jpg_fbuffer_free(zr);
 275                         return -ENOBUFS;
 276                 }
 277                 memset((void *) mem, 0, PAGE_SIZE);
 278                 zr->jpg_gbuf[i].frag_tab = (u32 *) mem;
 279                 zr->jpg_gbuf[i].frag_tab_bus = virt_to_bus((void *) mem);
 280
 281                 if (alloc_contig) {
 282                         mem = (unsigned long) kmalloc(zr->jpg_bufsize, GFP_KERNEL);
 283                         if (mem == 0) {
 284                                 jpg_fbuffer_free(zr);
 285                                 return -ENOBUFS;
 286                         }
 287                         zr->jpg_gbuf[i].frag_tab[0] = virt_to_bus((void *) mem);
 288                         zr->jpg_gbuf[i].frag_tab[1] = ((zr->jpg_bufsize / 4) << 1) | 1;
 289                         for (off = 0; off < zr->jpg_bufsize; off += PAGE_SIZE)
 290                                 mem_map_reserve(virt_to_page(mem + off));
 291                 } else {
 292                         /* jpg_bufsize is alreay page aligned */
 293                         for (j = 0; j < zr->jpg_bufsize / PAGE_SIZE; j++) {
 294                                 mem = get_free_page(GFP_KERNEL);
 295                                 if (mem == 0) {
 296                                         jpg_fbuffer_free(zr);
 297                                         return -ENOBUFS;
 298                                 }
 299                                 zr->jpg_gbuf[i].frag_tab[2 * j] = virt_to_bus((void *) mem);
 300                                 zr->jpg_gbuf[i].frag_tab[2 * j + 1] = (PAGE_SIZE / 4) << 1;
 301                                 mem_map_reserve(virt_to_page(mem));
 302                         }
 303
 304                         zr->jpg_gbuf[i].frag_tab[2 * j - 1] |= 1;
 305                 }
 306         }
 307
 308         DEBUG(printk("jpg_fbuffer_alloc: %d KB allocated\n",
 309                      (zr->jpg_nbufs * zr->jpg_bufsize) >> 10));
 310         zr->jpg_buffers_allocated = 1;
 311         return 0;
 312 }
 313
 314 /* free the MJPEG grab buffers */
 315 static void jpg_fbuffer_free(struct zoran *zr)
 316 {
 317         int i, j, off, alloc_contig;
 318         unsigned char *mem;
 319
 320         /* Decide if we should alloc contiguous or fragmented memory */
 321         /* This has to be identical in jpg_fbuffer_alloc and jpg_fbuffer_free */
 322
 323         alloc_contig = (zr->jpg_bufsize < MAX_KMALLOC_MEM);
 324
 325         for (i = 0; i < zr->jpg_nbufs; i++) {
 326                 if (!zr->jpg_gbuf[i].frag_tab)
 327                         continue;
 328
 329                 if (alloc_contig) {
 330                         if (zr->jpg_gbuf[i].frag_tab[0]) {
 331                                 mem = (unsigned char *) bus_to_virt(zr->jpg_gbuf[i].frag_tab[0]);
 332                                 for (off = 0; off < zr->jpg_bufsize; off += PAGE_SIZE)
 333                                         mem_map_unreserve(virt_to_page(mem + off));
 334                                 kfree((void *) mem);
 335                                 zr->jpg_gbuf[i].frag_tab[0] = 0;
 336                                 zr->jpg_gbuf[i].frag_tab[1] = 0;
 337                         }
 338                 } else {
 339                         for (j = 0; j < zr->jpg_bufsize / PAGE_SIZE; j++) {
 340                                 if (!zr->jpg_gbuf[i].frag_tab[2 * j])
 341                                         break;
 342                                 mem_map_unreserve(virt_to_page(bus_to_virt(zr->jpg_gbuf[i].frag_tab[2 * j])));
 343                                 free_page((unsigned long) bus_to_virt(zr->jpg_gbuf[i].frag_tab[2 * j]));
 344                                 zr->jpg_gbuf[i].frag_tab[2 * j] = 0;
 345                                 zr->jpg_gbuf[i].frag_tab[2 * j + 1] = 0;
 346                         }
 347                 }
 348
 349                 free_page((unsigned long) zr->jpg_gbuf[i].frag_tab);
 350                 zr->jpg_gbuf[i].frag_tab = NULL;
 351         }
 352         zr->jpg_buffers_allocated = 0;
 353 }
 354
 355
 356 /* ----------------------------------------------------------------------- */
 357
 358 /* I2C functions                                                           */
 359
 360 #define I2C_DELAY   10
 361
 362
 363 /* software I2C functions */
 364
 365 static void i2c_setlines(struct i2c_bus *bus, int ctrl, int data)
 366 {
 367         struct zoran *zr = (struct zoran *) bus->data;
 368         btwrite((data << 1) | ctrl, ZR36057_I2CBR);
 369         btread(ZR36057_I2CBR);
 370         udelay(I2C_DELAY);
 371 }
 372
 373 static int i2c_getdataline(struct i2c_bus *bus)
 374 {
 375         struct zoran *zr = (struct zoran *) bus->data;
 376         return (btread(ZR36057_I2CBR) >> 1) & 1;
 377 }
 378
 379 static void attach_inform(struct i2c_bus *bus, int id)
 380 {
 381         DEBUG(struct zoran *zr = (struct zoran *) bus->data);
 382         DEBUG(printk(BUZ_DEBUG "-%u: i2c attach %02x\n", zr->id, id));
 383 }
 384
 385 static void detach_inform(struct i2c_bus *bus, int id)
 386 {
 387         DEBUG(struct zoran *zr = (struct zoran *) bus->data);
 388         DEBUG(printk(BUZ_DEBUG "-%u: i2c detach %02x\n", zr->id, id));
 389 }
 390
 391 static struct i2c_bus zoran_i2c_bus_template =
 392 {
 393         "zr36057",
 394         I2C_BUSID_BT848,
 395         NULL,
 396
 397         SPIN_LOCK_UNLOCKED,
 398
 399         attach_inform,
 400         detach_inform,
 401
 402         i2c_setlines,
 403         i2c_getdataline,
 404         NULL,
 405         NULL,
 406 };
 407
 408
 409 /* ----------------------------------------------------------------------- */
 410
 411 static void GPIO(struct zoran *zr, unsigned bit, unsigned value)
 412 {
 413         u32 reg;
 414         u32 mask;
 415
 416         mask = 1 << (24 + bit);
 417         reg = btread(ZR36057_GPPGCR1) & ~mask;
 418         if (value) {
 419                 reg |= mask;
 420         }
 421         btwrite(reg, ZR36057_GPPGCR1);
 422         /* Stop any PCI posting on the GPIO bus */
 423         btread(ZR36057_I2CBR);
 424 }
 425
 426
 427 /*
 428  *   Set the registers for the size we have specified. Don't bother
 429  *   trying to understand this without the ZR36057 manual in front of
 430  *   you [AC].
 431  *
 432  *   PS: The manual is free for download in .pdf format from
 433  *   www.zoran.com - nicely done those folks.
 434  */
 435
 436 struct tvnorm {
 437         u16 Wt, Wa, Ht, Ha, HStart, VStart;
 438 };
 439
 440 static struct tvnorm tvnorms[] =
 441 {
 442    /* PAL-BDGHI */
 443         {864, 720, 625, 576, 31, 16},
 444    /* NTSC */
 445         {858, 720, 525, 480, 21, 8},
 446 };
 447 #define TVNORMS (sizeof(tvnorms) / sizeof(tvnorm))
 448
 449 static int format2bpp(int format)
 450 {
 451         int bpp;
 452
 453         /* Determine the number of bytes per pixel for the video format requested */
 454
 455         switch (format) {
 456
 457         case VIDEO_PALETTE_YUV422:
 458                 bpp = 2;
 459                 break;
 460
 461         case VIDEO_PALETTE_RGB555:
 462                 bpp = 2;
 463                 break;
 464
 465         case VIDEO_PALETTE_RGB565:
 466                 bpp = 2;
 467                 break;
 468
 469         case VIDEO_PALETTE_RGB24:
 470                 bpp = 3;
 471                 break;
 472
 473         case VIDEO_PALETTE_RGB32:
 474                 bpp = 4;
 475                 break;
 476
 477         default:
 478                 bpp = 0;
 479         }
 480
 481         return bpp;
 482 }
 483
 484 /*
 485  * set geometry
 486  */
 487 static void zr36057_set_vfe(struct zoran *zr, int video_width, int video_height,
 488                             unsigned int video_format)
 489 {
 490         struct tvnorm *tvn;
 491         unsigned HStart, HEnd, VStart, VEnd;
 492         unsigned DispMode;
 493         unsigned VidWinWid, VidWinHt;
 494         unsigned hcrop1, hcrop2, vcrop1, vcrop2;
 495         unsigned Wa, We, Ha, He;
 496         unsigned X, Y, HorDcm, VerDcm;
 497         u32 reg;
 498         unsigned mask_line_size;
 499
 500         if (zr->params.norm < 0 || zr->params.norm > 1) {
 501                 printk(KERN_ERR "%s: set_vfe: video_norm = %d not valid\n", zr->name,  zr->params.norm);
 502                 return;
 503         }
 504         if (video_width < BUZ_MIN_WIDTH || video_height < BUZ_MIN_HEIGHT) {
 505                 printk(KERN_ERR "%s: set_vfe: w=%d h=%d not valid\n", zr->name, video_width, video_height);
 506                 return;
 507         }
 508         tvn = &tvnorms[zr->params.norm];
 509
 510         Wa = tvn->Wa;
 511         Ha = tvn->Ha;
 512
 513         /* if window has more than half of active height,
 514            switch on interlacing - we want the full information */
 515
 516         zr->video_interlace = (video_height > Ha / 2);
 517
 518 /**** zr36057 ****/
 519
 520         /* horizontal */
 521         VidWinWid = video_width;
 522         X = (VidWinWid * 64 + tvn->Wa - 1) / tvn->Wa;
 523         We = (VidWinWid * 64) / X;
 524         HorDcm = 64 - X;
 525         hcrop1 = 2 * ((tvn->Wa - We) / 4);
 526         hcrop2 = tvn->Wa - We - hcrop1;
 527         HStart = tvn->HStart | 1;
 528         HEnd = HStart + tvn->Wa - 1;
 529         HStart += hcrop1;
 530         HEnd -= hcrop2;
 531         reg = ((HStart & ZR36057_VFEHCR_Hmask) << ZR36057_VFEHCR_HStart)
 532             | ((HEnd & ZR36057_VFEHCR_Hmask) << ZR36057_VFEHCR_HEnd);
 533         reg |= ZR36057_VFEHCR_HSPol;
 534         btwrite(reg, ZR36057_VFEHCR);
 535
 536         /* Vertical */
 537         DispMode = !zr->video_interlace;
 538         VidWinHt = DispMode ? video_height : video_height / 2;
 539         Y = (VidWinHt * 64 * 2 + tvn->Ha - 1) / tvn->Ha;
 540         He = (VidWinHt * 64) / Y;
 541         VerDcm = 64 - Y;
 542         vcrop1 = (tvn->Ha / 2 - He) / 2;
 543         vcrop2 = tvn->Ha / 2 - He - vcrop1;
 544         VStart = tvn->VStart;
 545         VEnd = VStart + tvn->Ha / 2 - 1;
 546         VStart += vcrop1;
 547         VEnd -= vcrop2;
 548         reg = ((VStart & ZR36057_VFEVCR_Vmask) << ZR36057_VFEVCR_VStart)
 549             | ((VEnd & ZR36057_VFEVCR_Vmask) << ZR36057_VFEVCR_VEnd);
 550         reg |= ZR36057_VFEVCR_VSPol;
 551         btwrite(reg, ZR36057_VFEVCR);
 552
 553         /* scaler and pixel format */
 554         reg = 0                 // ZR36057_VFESPFR_ExtFl /* Trying to live without ExtFl */
 555              | (HorDcm << ZR36057_VFESPFR_HorDcm)
 556             | (VerDcm << ZR36057_VFESPFR_VerDcm)
 557             | (DispMode << ZR36057_VFESPFR_DispMode)
 558             | ZR36057_VFESPFR_LittleEndian;
 559         /* RJ: I don't know, why the following has to be the opposite
 560            of the corresponding ZR36060 setting, but only this way
 561            we get the correct colors when uncompressing to the screen  */
 562         reg |= ZR36057_VFESPFR_VCLKPol;
 563         /* RJ: Don't know if that is needed for NTSC also */
 564         reg |= ZR36057_VFESPFR_TopField;
 565         switch (video_format) {
 566
 567         case VIDEO_PALETTE_YUV422:
 568                 reg |= ZR36057_VFESPFR_YUV422;
 569                 break;
 570
 571         case VIDEO_PALETTE_RGB555:
 572                 reg |= ZR36057_VFESPFR_RGB555 | ZR36057_VFESPFR_ErrDif;
 573                 break;
 574
 575         case VIDEO_PALETTE_RGB565:
 576                 reg |= ZR36057_VFESPFR_RGB565 | ZR36057_VFESPFR_ErrDif;
 577                 break;
 578
 579         case VIDEO_PALETTE_RGB24:
 580                 reg |= ZR36057_VFESPFR_RGB888 | ZR36057_VFESPFR_Pack24;
 581                 break;
 582
 583         case VIDEO_PALETTE_RGB32:
 584                 reg |= ZR36057_VFESPFR_RGB888;
 585                 break;
 586
 587         default:
 588                 printk(KERN_INFO "%s: Unknown color_fmt=%x\n", zr->name, video_format);
 589                 return;
 590
 591         }
 592         if (HorDcm >= 48) {
 593                 reg |= 3 << ZR36057_VFESPFR_HFilter;    /* 5 tap filter */
 594         } else if (HorDcm >= 32) {
 595                 reg |= 2 << ZR36057_VFESPFR_HFilter;    /* 4 tap filter */
 596         } else if (HorDcm >= 16) {
 597                 reg |= 1 << ZR36057_VFESPFR_HFilter;    /* 3 tap filter */
 598         }
 599         btwrite(reg, ZR36057_VFESPFR);
 600
 601         /* display configuration */
 602
 603         reg = (16 << ZR36057_VDCR_MinPix)
 604             | (VidWinHt << ZR36057_VDCR_VidWinHt)
 605             | (VidWinWid << ZR36057_VDCR_VidWinWid);
 606         if (triton)
 607                 reg &= ~ZR36057_VDCR_Triton;
 608         else
 609                 reg |= ZR36057_VDCR_Triton;
 610         btwrite(reg, ZR36057_VDCR);
 611
 612         /* Write overlay clipping mask data, but don't enable overlay clipping */
 613         /* RJ: since this makes only sense on the screen, we use
 614            zr->window.width instead of video_width */
 615
 616         mask_line_size = (BUZ_MAX_WIDTH + 31) / 32;
 617         reg = virt_to_bus(zr->overlay_mask);
 618         btwrite(reg, ZR36057_MMTR);
 619         reg = virt_to_bus(zr->overlay_mask + mask_line_size);
 620         btwrite(reg, ZR36057_MMBR);
 621         reg = mask_line_size - (zr->window.width + 31) / 32;
 622         if (DispMode == 0)
 623                 reg += mask_line_size;
 624         reg <<= ZR36057_OCR_MaskStride;
 625         btwrite(reg, ZR36057_OCR);
 626
 627 }
 628
 629 /*
 630  * Switch overlay on or off
 631  */
 632
 633 static void zr36057_overlay(struct zoran *zr, int on)
 634 {
 635         int fmt, bpp;
 636         u32 reg;
 637
 638         if (on) {
 639                 /* do the necessary settings ... */
 640
 641                 btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR);       /* switch it off first */
 642
 643                 switch (zr->buffer.depth) {
 644                 case 15:
 645                         fmt = VIDEO_PALETTE_RGB555;
 646                         bpp = 2;
 647                         break;
 648                 case 16:
 649                         fmt = VIDEO_PALETTE_RGB565;
 650                         bpp = 2;
 651                         break;
 652                 case 24:
 653                         fmt = VIDEO_PALETTE_RGB24;
 654                         bpp = 3;
 655                         break;
 656                 case 32:
 657                         fmt = VIDEO_PALETTE_RGB32;
 658                         bpp = 4;
 659                         break;
 660                 default:
 661                         fmt = 0;
 662                         bpp = 0;
 663                 }
 664
 665                 zr36057_set_vfe(zr, zr->window.width, zr->window.height, fmt);
 666
 667                 /* Start and length of each line MUST be 4-byte aligned.
 668                    This should be allready checked before the call to this routine.
 669                    All error messages are internal driver checking only! */
 670
 671                 /* video display top and bottom registers */
 672
 673                 reg = (u32) zr->buffer.base
 674                     + zr->window.x * bpp
 675                     + zr->window.y * zr->buffer.bytesperline;
 676                 btwrite(reg, ZR36057_VDTR);
 677                 if (reg & 3)
 678                         printk(KERN_ERR "%s: zr36057_overlay: video_address not aligned\n", zr->name);
 679                 if (zr->video_interlace)
 680                         reg += zr->buffer.bytesperline;
 681                 btwrite(reg, ZR36057_VDBR);
 682
 683                 /* video stride, status, and frame grab register */
 684
 685                 reg = zr->buffer.bytesperline - zr->window.width * bpp;
 686                 if (zr->video_interlace)
 687                         reg += zr->buffer.bytesperline;
 688                 if (reg & 3)
 689                         printk(KERN_ERR "%s: zr36057_overlay: video_stride not aligned\n", zr->name);
 690                 reg = (reg << ZR36057_VSSFGR_DispStride);
 691                 reg |= ZR36057_VSSFGR_VidOvf;   /* clear overflow status */
 692                 btwrite(reg, ZR36057_VSSFGR);
 693
 694                 /* Set overlay clipping */
 695
 696                 if (zr->window.clipcount)
 697                         btor(ZR36057_OCR_OvlEnable, ZR36057_OCR);
 698
 699                 /* ... and switch it on */
 700
 701                 btor(ZR36057_VDCR_VidEn, ZR36057_VDCR);
 702         } else {
 703                 /* Switch it off */
 704
 705                 btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR);
 706         }
 707 }
 708
 709 /*
 710  * The overlay mask has one bit for each pixel on a scan line,
 711  *  and the maximum window size is BUZ_MAX_WIDTH * BUZ_MAX_HEIGHT pixels.
 712  */
 713 static void write_overlay_mask(struct zoran *zr, struct video_clip *vp, int count)
 714 {
 715         unsigned mask_line_size = (BUZ_MAX_WIDTH + 31) / 32;
 716         u32 *mask;
 717         int x, y, width, height;
 718         unsigned i, j, k;
 719         u32 reg;
 720
 721         /* fill mask with one bits */
 722         memset(zr->overlay_mask, ~0, mask_line_size * 4 * BUZ_MAX_HEIGHT);
 723         reg = 0;
 724
 725         for (i = 0; i < count; ++i) {
 726                 /* pick up local copy of clip */
 727                 x = vp[i].x;
 728                 y = vp[i].y;
 729                 width = vp[i].width;
 730                 height = vp[i].height;
 731
 732                 /* trim clips that extend beyond the window */
 733                 if (x < 0) {
 734                         width += x;
 735                         x = 0;
 736                 }
 737                 if (y < 0) {
 738                         height += y;
 739                         y = 0;
 740                 }
 741                 if (x + width > zr->window.width) {
 742                         width = zr->window.width - x;
 743                 }
 744                 if (y + height > zr->window.height) {
 745                         height = zr->window.height - y;
 746                 }
 747                 /* ignore degenerate clips */
 748                 if (height <= 0) {
 749                         continue;
 750                 }
 751                 if (width <= 0) {
 752                         continue;
 753                 }
 754                 /* apply clip for each scan line */
 755                 for (j = 0; j < height; ++j) {
 756                         /* reset bit for each pixel */
 757                         /* this can be optimized later if need be */
 758                         mask = zr->overlay_mask + (y + j) * mask_line_size;
 759                         for (k = 0; k < width; ++k) {
 760                                 mask[(x + k) / 32] &= ~((u32) 1 << (x + k) % 32);
 761                         }
 762                 }
 763         }
 764 }
 765
 766 /* Enable/Disable uncompressed memory grabbing of the 36057 */
 767
 768 static void zr36057_set_memgrab(struct zoran *zr, int mode)
 769 {
 770         if (mode) {
 771                 if (btread(ZR36057_VSSFGR) & (ZR36057_VSSFGR_SnapShot | ZR36057_VSSFGR_FrameGrab))
 772                         printk(KERN_WARNING "%s: zr36057_set_memgrab_on with SnapShot or FrameGrab on ???\n", zr->name);
 773
 774                 /* switch on VSync interrupts */
 775
 776                 btwrite(IRQ_MASK, ZR36057_ISR);         // Clear Interrupts
 777
 778                 btor(ZR36057_ICR_GIRQ0, ZR36057_ICR);
 779
 780                 /* enable SnapShot */
 781
 782                 btor(ZR36057_VSSFGR_SnapShot, ZR36057_VSSFGR);
 783
 784                 /* Set zr36057 video front end  and enable video */
 785
 786 #ifdef XAWTV_HACK
 787                 zr36057_set_vfe(zr, zr->gwidth > 720 ? 720 : zr->gwidth, zr->gheight, zr->gformat);
 788 #else
 789                 zr36057_set_vfe(zr, zr->gwidth, zr->gheight, zr->gformat);
 790 #endif
 791
 792                 zr->v4l_memgrab_active = 1;
 793         } else {
 794                 zr->v4l_memgrab_active = 0;
 795
 796                 /* switch off VSync interrupts */
 797
 798                 btand(~ZR36057_ICR_GIRQ0, ZR36057_ICR);
 799
 800                 /* reenable grabbing to screen if it was running */
 801
 802                 if (zr->v4l_overlay_active) {
 803                         zr36057_overlay(zr, 1);
 804                 } else {
 805                         btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR);
 806                         btand(~ZR36057_VSSFGR_SnapShot, ZR36057_VSSFGR);
 807                 }
 808         }
 809 }
 810
 811 static int wait_grab_pending(struct zoran *zr)
 812 {
 813         unsigned long flags;
 814
 815         /* wait until all pending grabs are finished */
 816
 817         if (!zr->v4l_memgrab_active)
 818                 return 0;
 819
 820         while (zr->v4l_pend_tail != zr->v4l_pend_head) {
 821                 interruptible_sleep_on(&zr->v4l_capq);
 822                 if (signal_pending(current))
 823                         return -ERESTARTSYS;
 824         }
 825
 826         spin_lock_irqsave(&zr->lock, flags);
 827         zr36057_set_memgrab(zr, 0);
 828         spin_unlock_irqrestore(&zr->lock, flags);
 829
 830         return 0;
 831 }
 832
 833 /*
 834  *   V4L Buffer grabbing
 835  */
 836
 837 static int v4l_grab(struct zoran *zr, struct video_mmap *mp)
 838 {
 839         unsigned long flags;
 840         int res, bpp;
 841
 842         /*
 843          * There is a long list of limitations to what is allowed to be grabbed
 844          * We don't output error messages her, since some programs (e.g. xawtv)
 845          * just try several settings to find out what is valid or not.
 846          */
 847
 848         /* No grabbing outside the buffer range! */
 849
 850         if (mp->frame >= v4l_nbufs || mp->frame < 0)
 851                 return -EINVAL;
 852
 853         /* Check size and format of the grab wanted */
 854
 855         if (mp->height < BUZ_MIN_HEIGHT || mp->width < BUZ_MIN_WIDTH)
 856                 return -EINVAL;
 857         if (mp->height > BUZ_MAX_HEIGHT || mp->width > BUZ_MAX_WIDTH)
 858                 return -EINVAL;
 859
 860         bpp = format2bpp(mp->format);
 861         if (bpp == 0)
 862                 return -EINVAL;
 863
 864         /* Check against available buffer size */
 865
 866         if (mp->height * mp->width * bpp > v4l_bufsize)
 867                 return -EINVAL;
 868
 869         /* The video front end needs 4-byte alinged line sizes */
 870
 871         if ((bpp == 2 && (mp->width & 1)) || (bpp == 3 && (mp->width & 3)))
 872                 return -EINVAL;
 873
 874         /*
 875          * To minimize the time spent in the IRQ routine, we avoid setting up
 876          * the video front end there.
 877          * If this grab has different parameters from a running streaming capture
 878          * we stop the streaming capture and start it over again.
 879          */
 880
 881         if (zr->v4l_memgrab_active &&
 882             (zr->gwidth != mp->width || zr->gheight != mp->height || zr->gformat != mp->format)) {
 883                 res = wait_grab_pending(zr);
 884                 if (res)
 885                         return res;
 886         }
 887         zr->gwidth = mp->width;
 888         zr->gheight = mp->height;
 889         zr->gformat = mp->format;
 890         zr->gbpl = bpp * zr->gwidth;
 891
 892
 893         spin_lock_irqsave(&zr->lock, flags);
 894
 895         /* make sure a grab isn't going on currently with this buffer */
 896
 897         switch (zr->v4l_gbuf[mp->frame].state) {
 898
 899         default:
 900         case BUZ_STATE_PEND:
 901                 res = -EBUSY;   /* what are you doing? */
 902                 break;
 903
 904         case BUZ_STATE_USER:
 905         case BUZ_STATE_DONE:
 906                 /* since there is at least one unused buffer there's room for at least one more pend[] entry */
 907                 zr->v4l_pend[zr->v4l_pend_head++ & V4L_MASK_FRAME] = mp->frame;
 908                 zr->v4l_gbuf[mp->frame].state = BUZ_STATE_PEND;
 909                 res = 0;
 910                 break;
 911
 912         }
 913
 914         /* put the 36057 into frame grabbing mode */
 915
 916         if (!res && !zr->v4l_memgrab_active)
 917                 zr36057_set_memgrab(zr, 1);
 918
 919         spin_unlock_irqrestore(&zr->lock, flags);
 920
 921         return res;
 922 }
 923
 924 /*
 925  * Sync on a V4L buffer
 926  */
 927
 928 static int v4l_sync(struct zoran *zr, int frame)
 929 {
 930         unsigned long flags;
 931
 932
 933         /* check passed-in frame number */
 934         if (frame >= v4l_nbufs || frame < 0) {
 935                 printk(KERN_ERR "%s: v4l_sync: frame %d is invalid\n", zr->name, frame);
 936                 return -EINVAL;
 937         }
 938         /* Check if is buffer was queued at all */
 939
 940         if (zr->v4l_gbuf[frame].state == BUZ_STATE_USER) {
 941 //              printk(KERN_ERR "%s: v4l_sync: Trying to sync on a buffer which was not queued?\n", zr->name);
 942                 return -EINVAL;
 943         }
 944         /* wait on this buffer to get ready */
 945
 946         while (zr->v4l_gbuf[frame].state == BUZ_STATE_PEND) {
 947                 interruptible_sleep_on(&zr->v4l_capq);
 948                 if (signal_pending(current))
 949                         return -ERESTARTSYS;
 950         }
 951
 952         /* buffer should now be in BUZ_STATE_DONE */
 953
 954         if (zr->v4l_gbuf[frame].state != BUZ_STATE_DONE)
 955                 printk(KERN_ERR "%s: v4l_sync - internal error\n", zr->name);
 956
 957         /* Check if streaming capture has finished */
 958
 959         spin_lock_irqsave(&zr->lock, flags);
 960
 961         if (zr->v4l_pend_tail == zr->v4l_pend_head)
 962                 zr36057_set_memgrab(zr, 0);
 963
 964         spin_unlock_irqrestore(&zr->lock, flags);
 965
 966         return 0;
 967 }
 968 /*****************************************************************************
 969  *                                                                           *
 970  *  Set up the Buz-specific MJPEG part                                       *
 971  *                                                                           *
 972  *****************************************************************************/
 973
 974 /*
 975  *      Wait til post office is no longer busy
 976  */
 977
 978 static int post_office_wait(struct zoran *zr)
 979 {
 980         u32 por;
 981         u32 ct=0;
 982
 983         while (((por = btread(ZR36057_POR)) & (ZR36057_POR_POPen | ZR36057_POR_POTime)) == ZR36057_POR_POPen) {
 984                 ct++;
 985                 if(ct>100000)
 986                 {
 987                         printk(KERN_ERR "%s: timeout on post office.\n", zr->name);
 988                         return -1;
 989                 }
 990                 /* wait for something to happen */
 991         }
 992         if ((por & ZR36057_POR_POPen) != 0) {
 993                 printk(KERN_WARNING "%s: pop pending %08x\n", zr->name, por);
 994                 return -1;
 995         }
 996         if ((por & (ZR36057_POR_POTime | ZR36057_POR_POPen)) != 0) {
 997                 printk(KERN_WARNING "%s: pop timeout %08x\n", zr->name, por);
 998                 return -1;
 999         }
1000         return 0;
1001 }
1002
1003 static int post_office_write(struct zoran *zr, unsigned guest, unsigned reg, unsigned value)
1004 {
1005         u32 por;
1006
1007         post_office_wait(zr);
1008         por = ZR36057_POR_PODir | ZR36057_POR_POTime | ((guest & 7) << 20) | ((reg & 7) << 16) | (value & 0xFF);
1009         btwrite(por, ZR36057_POR);
1010         return post_office_wait(zr);
1011 }
1012
1013 static int post_office_read(struct zoran *zr, unsigned guest, unsigned reg)
1014 {
1015         u32 por;
1016
1017         post_office_wait(zr);
1018         por = ZR36057_POR_POTime | ((guest & 7) << 20) | ((reg & 7) << 16);
1019         btwrite(por, ZR36057_POR);
1020         if (post_office_wait(zr) < 0) {
1021                 return -1;
1022         }
1023         return btread(ZR36057_POR) & 0xFF;
1024 }
1025
1026 static int zr36060_write_8(struct zoran *zr, unsigned reg, unsigned val)
1027 {
1028         if (post_office_wait(zr)
1029             || post_office_write(zr, 0, 1, reg >> 8)
1030             || post_office_write(zr, 0, 2, reg)) {
1031                 return -1;
1032         }
1033         return post_office_write(zr, 0, 3, val);
1034 }
1035
1036 static int zr36060_write_16(struct zoran *zr, unsigned reg, unsigned val)
1037 {
1038         if (zr36060_write_8(zr, reg + 0, val >> 8)) {
1039                 return -1;
1040         }
1041         return zr36060_write_8(zr, reg + 1, val >> 0);
1042 }
1043
1044 static int zr36060_write_24(struct zoran *zr, unsigned reg, unsigned val)
1045 {
1046         if (zr36060_write_8(zr, reg + 0, val >> 16)) {
1047                 return -1;
1048         }
1049         return zr36060_write_16(zr, reg + 1, val >> 0);
1050 }
1051
1052 static int zr36060_write_32(struct zoran *zr, unsigned reg, unsigned val)
1053 {
1054         if (zr36060_write_16(zr, reg + 0, val >> 16)) {
1055                 return -1;
1056         }
1057         return zr36060_write_16(zr, reg + 2, val >> 0);
1058 }
1059
1060 static u32 zr36060_read_8(struct zoran *zr, unsigned reg)
1061 {
1062         if (post_office_wait(zr)
1063             || post_office_write(zr, 0, 1, reg >> 8)
1064             || post_office_write(zr, 0, 2, reg)) {
1065                 return -1;
1066         }
1067         return post_office_read(zr, 0, 3) & 0xFF;
1068 }
1069
1070 static int zr36060_reset(struct zoran *zr)
1071 {
1072         return post_office_write(zr, 3, 0, 0);
1073 }
1074
1075 static void zr36060_sleep(struct zoran *zr, int sleep)
1076 {
1077         GPIO(zr, 1, !sleep);
1078 }
1079
1080
1081 static void zr36060_set_jpg(struct zoran *zr, enum zoran_codec_mode mode)
1082 {
1083         struct tvnorm *tvn;
1084         u32 reg;
1085         int size;
1086
1087         reg = (1 << 0)          /* CodeMstr */
1088             |(0 << 2)           /* CFIS=0 */
1089             |(0 << 6)           /* Endian=0 */
1090             |(0 << 7);          /* Code16=0 */
1091         zr36060_write_8(zr, 0x002, reg);
1092
1093         switch (mode) {
1094
1095         case BUZ_MODE_MOTION_DECOMPRESS:
1096         case BUZ_MODE_STILL_DECOMPRESS:
1097                 reg = 0x00;     /* Codec mode = decompression */
1098                 break;
1099
1100         case BUZ_MODE_MOTION_COMPRESS:
1101         case BUZ_MODE_STILL_COMPRESS:
1102         default:
1103                 reg = 0xa4;     /* Codec mode = compression with variable scale factor */
1104                 break;
1105
1106         }
1107         zr36060_write_8(zr, 0x003, reg);
1108
1109         reg = 0x00;             /* reserved, mbz */
1110         zr36060_write_8(zr, 0x004, reg);
1111
1112         reg = 0xff;             /* 510 bits/block */
1113         zr36060_write_8(zr, 0x005, reg);
1114
1115         /* JPEG markers */
1116         reg = (zr->params.jpeg_markers) & 0x38; /* DRI, DQT, DHT */
1117         if (zr->params.COM_len)
1118                 reg |= JPEG_MARKER_COM;
1119         if (zr->params.APP_len)
1120                 reg |= JPEG_MARKER_APP;
1121         zr36060_write_8(zr, 0x006, reg);
1122
1123         reg = (0 << 3)          /* DATERR=0 */
1124             |(0 << 2)           /* END=0 */
1125             |(0 << 1)           /* EOI=0 */
1126             |(0 << 0);          /* EOAV=0 */
1127         zr36060_write_8(zr, 0x007, reg);
1128
1129         /* code volume */
1130
1131         /* Target field size in pixels: */
1132         tvn = &tvnorms[zr->params.norm];
1133         size = (tvn->Ha / 2) * (tvn->Wa) / (zr->params.HorDcm) / (zr->params.VerDcm);
1134
1135         /* Target compressed field size in bits: */
1136         size = size * 16;       /* uncompressed size in bits */
1137         size = size * zr->params.quality / 400; /* quality = 100 is a compression ratio 1:4 */
1138
1139         /* Lower limit (arbitrary, 1 KB) */
1140         if (size < 8192)
1141                 size = 8192;
1142
1143         /* Upper limit: 7/8 of the code buffers */
1144         if (size * zr->params.field_per_buff > zr->jpg_bufsize * 7)
1145                 size = zr->jpg_bufsize * 7 / zr->params.field_per_buff;
1146
1147         reg = size;
1148         zr36060_write_32(zr, 0x009, reg);
1149
1150         /* how do we set initial SF as a function of quality parameter? */
1151         reg = 0x0100;           /* SF=1.0 */
1152         zr36060_write_16(zr, 0x011, reg);
1153
1154         reg = 0x00ffffff;       /* AF=max */
1155         zr36060_write_24(zr, 0x013, reg);
1156
1157         reg = 0x0000;           /* test */
1158         zr36060_write_16(zr, 0x024, reg);
1159 }
1160
1161 static void zr36060_set_video(struct zoran *zr, enum zoran_codec_mode mode)
1162 {
1163         struct tvnorm *tvn;
1164         u32 reg;
1165
1166         reg = (0 << 7)          /* Video8=0 */
1167             |(0 << 6)           /* Range=0 */
1168             |(0 << 3)           /* FlDet=0 */
1169             |(1 << 2)           /* FlVedge=1 */
1170             |(0 << 1)           /* FlExt=0 */
1171             |(0 << 0);          /* SyncMstr=0 */
1172
1173         /* According to ZR36067 documentation, FlDet should correspond
1174            to the odd_even flag of the ZR36067 */
1175         if (zr->params.odd_even)
1176                 reg |= (1 << 3);
1177
1178         if (mode != BUZ_MODE_STILL_DECOMPRESS) {
1179                 /* limit pixels to range 16..235 as per CCIR-601 */
1180                 reg |= (1 << 6);        /* Range=1 */
1181         }
1182         zr36060_write_8(zr, 0x030, reg);
1183
1184         reg = (0 << 7)          /* VCLKPol=0 */
1185             |(0 << 6)           /* PValPol=0 */
1186             |(1 << 5)           /* PoePol=1 */
1187             |(0 << 4)           /* SImgPol=0 */
1188             |(0 << 3)           /* BLPol=0 */
1189             |(0 << 2)           /* FlPol=0 */
1190             |(0 << 1)           /* HSPol=0, sync on falling edge */
1191             |(1 << 0);          /* VSPol=1 */
1192         zr36060_write_8(zr, 0x031, reg);
1193
1194         switch (zr->params.HorDcm) {
1195         default:
1196         case 1:
1197                 reg = (0 << 0);
1198                 break;          /* HScale = 0 */
1199
1200         case 2:
1201                 reg = (1 << 0);
1202                 break;          /* HScale = 1 */
1203
1204         case 4:
1205                 reg = (2 << 0);
1206                 break;          /* HScale = 2 */
1207         }
1208         if (zr->params.VerDcm == 2)
1209                 reg |= (1 << 2);
1210         zr36060_write_8(zr, 0x032, reg);
1211
1212         reg = 0x80;             /* BackY */
1213         zr36060_write_8(zr, 0x033, reg);
1214
1215         reg = 0xe0;             /* BackU */
1216         zr36060_write_8(zr, 0x034, reg);
1217
1218         reg = 0xe0;             /* BackV */
1219         zr36060_write_8(zr, 0x035, reg);
1220
1221         /* sync generator */
1222
1223         tvn = &tvnorms[zr->params.norm];
1224
1225         reg = tvn->Ht - 1;      /* Vtotal */
1226         zr36060_write_16(zr, 0x036, reg);
1227
1228         reg = tvn->Wt - 1;      /* Htotal */
1229         zr36060_write_16(zr, 0x038, reg);
1230
1231         reg = 6 - 1;            /* VsyncSize */
1232         zr36060_write_8(zr, 0x03a, reg);
1233
1234         reg = 100 - 1;          /* HsyncSize */
1235         zr36060_write_8(zr, 0x03b, reg);
1236
1237         reg = tvn->VStart - 1;  /* BVstart */
1238         zr36060_write_8(zr, 0x03c, reg);
1239
1240         reg += tvn->Ha / 2;     /* BVend */
1241         zr36060_write_16(zr, 0x03e, reg);
1242
1243         reg = tvn->HStart - 1;  /* BHstart */
1244         zr36060_write_8(zr, 0x03d, reg);
1245
1246         reg += tvn->Wa;         /* BHend */
1247         zr36060_write_16(zr, 0x040, reg);
1248
1249         /* active area */
1250         reg = zr->params.img_y + tvn->VStart;   /* Vstart */
1251         zr36060_write_16(zr, 0x042, reg);
1252
1253         reg += zr->params.img_height;   /* Vend */
1254         zr36060_write_16(zr, 0x044, reg);
1255
1256         reg = zr->params.img_x + tvn->HStart;   /* Hstart */
1257         zr36060_write_16(zr, 0x046, reg);
1258
1259         reg += zr->params.img_width;    /* Hend */
1260         zr36060_write_16(zr, 0x048, reg);
1261
1262         /* subimage area */
1263         reg = zr->params.img_y + tvn->VStart;   /* SVstart */
1264         zr36060_write_16(zr, 0x04a, reg);
1265
1266         reg += zr->params.img_height;   /* SVend */
1267         zr36060_write_16(zr, 0x04c, reg);
1268
1269         reg = zr->params.img_x + tvn->HStart;   /* SHstart */
1270         zr36060_write_16(zr, 0x04e, reg);
1271
1272         reg += zr->params.img_width;    /* SHend */
1273         zr36060_write_16(zr, 0x050, reg);
1274 }
1275
1276 static void zr36060_set_jpg_SOF(struct zoran *zr)
1277 {
1278         u32 reg;
1279
1280
1281         reg = 0xffc0;           /* SOF marker */
1282         zr36060_write_16(zr, 0x060, reg);
1283
1284         reg = 17;               /* SOF length */
1285         zr36060_write_16(zr, 0x062, reg);
1286
1287         reg = 8;                /* precision 8 bits */
1288         zr36060_write_8(zr, 0x064, reg);
1289
1290         reg = zr->params.img_height / zr->params.VerDcm;        /* image height */
1291         zr36060_write_16(zr, 0x065, reg);
1292
1293         reg = zr->params.img_width / zr->params.HorDcm; /* image width */
1294         zr36060_write_16(zr, 0x067, reg);
1295
1296         reg = 3;                /* 3 color components */
1297         zr36060_write_8(zr, 0x069, reg);
1298
1299         reg = 0x002100;         /* Y component */
1300         zr36060_write_24(zr, 0x06a, reg);
1301
1302         reg = 0x011101;         /* U component */
1303         zr36060_write_24(zr, 0x06d, reg);
1304
1305         reg = 0x021101;         /* V component */
1306         zr36060_write_24(zr, 0x070, reg);
1307 }
1308
1309 static void zr36060_set_jpg_SOS(struct zoran *zr)
1310 {
1311         u32 reg;
1312
1313
1314         reg = 0xffda;           /* SOS marker */
1315         zr36060_write_16(zr, 0x07a, reg);
1316
1317         reg = 12;               /* SOS length */
1318         zr36060_write_16(zr, 0x07c, reg);
1319
1320         reg = 3;                /* 3 color components */
1321         zr36060_write_8(zr, 0x07e, reg);
1322
1323         reg = 0x0000;           /* Y component */
1324         zr36060_write_16(zr, 0x07f, reg);
1325
1326         reg = 0x0111;           /* U component */
1327         zr36060_write_16(zr, 0x081, reg);
1328
1329         reg = 0x0211;           /* V component */
1330         zr36060_write_16(zr, 0x083, reg);
1331
1332         reg = 0x003f00;         /* Start, end spectral scans */
1333         zr36060_write_24(zr, 0x085, reg);
1334 }
1335
1336 static void zr36060_set_jpg_DRI(struct zoran *zr)
1337 {
1338         u32 reg;
1339
1340
1341         reg = 0xffdd;           /* DRI marker */
1342         zr36060_write_16(zr, 0x0c0, reg);
1343
1344         reg = 4;                /* DRI length */
1345         zr36060_write_16(zr, 0x0c2, reg);
1346
1347         reg = 8;                /* length in MCUs */
1348         zr36060_write_16(zr, 0x0c4, reg);
1349 }
1350
1351 static void zr36060_set_jpg_DQT(struct zoran *zr)
1352 {
1353         unsigned i;
1354         unsigned adr;
1355         static const u8 dqt[] =
1356         {
1357                 0xff, 0xdb,     /* DHT marker */
1358                 0x00, 0x84,     /* DHT length */
1359                 0x00,           /* table ID 0 */
1360                 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
1361                 0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28,
1362                 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
1363                 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
1364                 0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0x44,
1365                 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57,
1366                 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
1367                 0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63,
1368                 0x01,           /* table ID 1 */
1369                 0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
1370                 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
1371                 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
1372                 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
1373                 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
1374                 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
1375                 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
1376                 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63
1377         };
1378
1379         /* write fixed quantitization tables */
1380         adr = 0x0cc;
1381         for (i = 0; i < sizeof(dqt); ++i) {
1382                 zr36060_write_8(zr, adr++, dqt[i]);
1383         }
1384 }
1385
1386 static void zr36060_set_jpg_DHT(struct zoran *zr)
1387 {
1388         unsigned i;
1389         unsigned adr;
1390         static const u8 dht[] =
1391         {
1392                 0xff, 0xc4,     /* DHT marker */
1393                 0x01, 0xa2,     /* DHT length */
1394                 0x00,           /* table class 0, ID 0 */
1395                 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,         /* # codes of length 1..8 */
1396                 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         /* # codes of length 8..16 */
1397                 0x00,           /* values for codes of length 2 */
1398                 0x01, 0x02, 0x03, 0x04, 0x05,   /* values for codes of length 3 */
1399                 0x06,           /* values for codes of length 4 */
1400                 0x07,           /* values for codes of length 5 */
1401                 0x08,           /* values for codes of length 6 */
1402                 0x09,           /* values for codes of length 7 */
1403                 0x0a,           /* values for codes of length 8 */
1404                 0x0b,           /* values for codes of length 9 */
1405                 0x01,           /* table class 0, ID 1 */
1406                 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,         /* # codes of length 1..8 */
1407                 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,         /* # codes of length 9..16 */
1408                 0x00, 0x01, 0x02,       /* values for codes of length 2 */
1409                 0x03,           /* values for codes of length 3 */
1410                 0x04,           /* values for codes of length 4 */
1411                 0x05,           /* values for codes of length 5 */
1412                 0x06,           /* values for codes of length 6 */
1413                 0x07,           /* values for codes of length 7 */
1414                 0x08,           /* values for codes of length 8 */
1415                 0x09,           /* values for codes of length 9 */
1416                 0x0a,           /* values for codes of length 10 */
1417                 0x0b,           /* values for codes of length 11 */
1418                 0x10,
1419                 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
1420                 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d,
1421                 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
1422                 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
1423                 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
1424                 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
1425                 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
1426                 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
1427                 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
1428                 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
1429                 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
1430                 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
1431                 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
1432                 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
1433                 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
1434                 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
1435                 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
1436                 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
1437                 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
1438                 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
1439                 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
1440                 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
1441                 0xf9, 0xfa, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04,
1442                 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00,
1443                 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
1444                 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
1445                 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08,
1446                 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23,
1447                 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a,
1448                 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18,
1449                 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35,
1450                 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
1451                 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
1452                 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65,
1453                 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
1454                 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84,
1455                 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93,
1456                 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2,
1457                 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
1458                 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
1459                 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8,
1460                 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
1461                 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
1462                 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5,
1463                 0xf6, 0xf7, 0xf8, 0xf9, 0xfa
1464         };
1465
1466         /* write fixed Huffman tables */
1467         adr = 0x1d4;
1468         for (i = 0; i < sizeof(dht); ++i) {
1469                 zr36060_write_8(zr, adr++, dht[i]);
1470         }
1471 }
1472
1473 static void zr36060_set_jpg_APP(struct zoran *zr)
1474 {
1475         unsigned adr;
1476         int len, i;
1477         u32 reg;
1478
1479
1480         len = zr->params.APP_len;
1481         if (len < 0)
1482                 len = 0;
1483         if (len > 60)
1484                 len = 60;
1485
1486         i = zr->params.APPn;
1487         if (i < 0)
1488                 i = 0;
1489         if (i > 15)
1490                 i = 15;
1491
1492         reg = 0xffe0 + i;       /* APPn marker */
1493         zr36060_write_16(zr, 0x380, reg);
1494
1495         reg = len + 2;          /* APPn len */
1496         zr36060_write_16(zr, 0x382, reg);
1497
1498         /* write APPn data */
1499         adr = 0x384;
1500         for (i = 0; i < 60; i++) {
1501                 zr36060_write_8(zr, adr++, (i < len ? zr->params.APP_data[i] : 0));
1502         }
1503 }
1504
1505 static void zr36060_set_jpg_COM(struct zoran *zr)
1506 {
1507         unsigned adr;
1508         int len, i;
1509         u32 reg;
1510
1511
1512         len = zr->params.COM_len;
1513         if (len < 0)
1514                 len = 0;
1515         if (len > 60)
1516                 len = 60;
1517
1518         reg = 0xfffe;           /* COM marker */
1519         zr36060_write_16(zr, 0x3c0, reg);
1520
1521         reg = len + 2;          /* COM len */
1522         zr36060_write_16(zr, 0x3c2, reg);
1523
1524         /* write COM data */
1525         adr = 0x3c4;
1526         for (i = 0; i < 60; i++) {
1527                 zr36060_write_8(zr, adr++, (i < len ? zr->params.COM_data[i] : 0));
1528         }
1529 }
1530
1531 static void zr36060_set_cap(struct zoran *zr, enum zoran_codec_mode mode)
1532 {
1533         unsigned i;
1534         u32 reg;
1535
1536         zr36060_reset(zr);
1537         mdelay(10);
1538
1539         reg = (0 << 7)          /* Load=0 */
1540             |(1 << 0);          /* SynRst=1 */
1541         zr36060_write_8(zr, 0x000, reg);
1542
1543         zr36060_set_jpg(zr, mode);
1544         zr36060_set_video(zr, mode);
1545         zr36060_set_jpg_SOF(zr);
1546         zr36060_set_jpg_SOS(zr);
1547         zr36060_set_jpg_DRI(zr);
1548         zr36060_set_jpg_DQT(zr);
1549         zr36060_set_jpg_DHT(zr);
1550         zr36060_set_jpg_APP(zr);
1551         zr36060_set_jpg_COM(zr);
1552
1553         reg = (1 << 7)          /* Load=1 */
1554             |(0 << 0);          /* SynRst=0 */
1555         zr36060_write_8(zr, 0x000, reg);
1556
1557         /* wait for codec to unbusy */
1558         for (i = 0; i < 1000; ++i) {
1559                 reg = zr36060_read_8(zr, 0x001);
1560                 if ((reg & (1 << 7)) == 0) {
1561                         DEBUG(printk(KERN_DEBUG "060: loaded, loops=%u\n", i));
1562                         return;
1563                 }
1564                 udelay(1000);
1565         }
1566         printk(KERN_INFO "060: stuck busy, statux=%02x\n", reg);
1567 }
1568
1569 static void zr36057_set_jpg(struct zoran *zr, enum zoran_codec_mode mode)
1570 {
1571         struct tvnorm *tvn;
1572         u32 reg;
1573         int i;
1574
1575         tvn = &tvnorms[zr->params.norm];
1576
1577         /* assert P_Reset */
1578         btwrite(0, ZR36057_JPC);
1579
1580         /* re-initialize DMA ring stuff */
1581         zr->jpg_que_head = 0;
1582         zr->jpg_dma_head = 0;
1583         zr->jpg_dma_tail = 0;
1584         zr->jpg_que_tail = 0;
1585         zr->jpg_seq_num = 0;
1586         for (i = 0; i < BUZ_NUM_STAT_COM; ++i) {
1587                 zr->stat_com[i] = 1;    /* mark as unavailable to zr36057 */
1588         }
1589         for (i = 0; i < zr->jpg_nbufs; i++) {
1590                 zr->jpg_gbuf[i].state = BUZ_STATE_USER; /* nothing going on */
1591         }
1592
1593         /* MJPEG compression mode */
1594         switch (mode) {
1595
1596         case BUZ_MODE_MOTION_COMPRESS:
1597         default:
1598                 reg = ZR36057_JMC_MJPGCmpMode;
1599                 break;
1600
1601         case BUZ_MODE_MOTION_DECOMPRESS:
1602                 reg = ZR36057_JMC_MJPGExpMode;
1603                 reg |= ZR36057_JMC_SyncMstr;
1604                 /* RJ: The following is experimental - improves the output to screen */
1605                 if (zr->params.VFIFO_FB)
1606                         reg |= ZR36057_JMC_VFIFO_FB;
1607                 break;
1608
1609         case BUZ_MODE_STILL_COMPRESS:
1610                 reg = ZR36057_JMC_JPGCmpMode;
1611                 break;
1612
1613         case BUZ_MODE_STILL_DECOMPRESS:
1614                 reg = ZR36057_JMC_JPGExpMode;
1615                 break;
1616
1617         }
1618         reg |= ZR36057_JMC_JPG;
1619         if (zr->params.field_per_buff == 1)
1620                 reg |= ZR36057_JMC_Fld_per_buff;
1621         btwrite(reg, ZR36057_JMC);
1622
1623         /* vertical */
1624         btor(ZR36057_VFEVCR_VSPol, ZR36057_VFEVCR);
1625         reg = (6 << ZR36057_VSP_VsyncSize) | (tvn->Ht << ZR36057_VSP_FrmTot);
1626         btwrite(reg, ZR36057_VSP);
1627         reg = ((zr->params.img_y + tvn->VStart) << ZR36057_FVAP_NAY)
1628             | (zr->params.img_height << ZR36057_FVAP_PAY);
1629         btwrite(reg, ZR36057_FVAP);
1630
1631         /* horizontal */
1632         btor(ZR36057_VFEHCR_HSPol, ZR36057_VFEHCR);
1633         reg = ((tvn->Wt - 100) << ZR36057_HSP_HsyncStart) | (tvn->Wt << ZR36057_HSP_LineTot);
1634         btwrite(reg, ZR36057_HSP);
1635         reg = ((zr->params.img_x + tvn->HStart) << ZR36057_FHAP_NAX)
1636             | (zr->params.img_width << ZR36057_FHAP_PAX);
1637         btwrite(reg, ZR36057_FHAP);
1638
1639         /* field process parameters */
1640         if (zr->params.odd_even)
1641                 reg = ZR36057_FPP_Odd_Even;
1642         else
1643                 reg = 0;
1644         btwrite(reg, ZR36057_FPP);
1645
1646         /* Set proper VCLK Polarity, else colors will be wrong during playback */
1647         btor(ZR36057_VFESPFR_VCLKPol, ZR36057_VFESPFR);
1648
1649         /* code base address and FIFO threshold */
1650         reg = virt_to_bus(zr->stat_com);
1651         btwrite(reg, ZR36057_JCBA);
1652         reg = 0x50;
1653         btwrite(reg, ZR36057_JCFT);
1654
1655         /* JPEG codec guest ID */
1656         reg = (1 << ZR36057_JCGI_JPEGuestID) | (0 << ZR36057_JCGI_JPEGuestReg);
1657         btwrite(reg, ZR36057_JCGI);
1658
1659         /* Code transfer guest ID */
1660         reg = (0 << ZR36057_MCTCR_CodGuestID) | (3 << ZR36057_MCTCR_CodGuestReg);
1661         reg |= ZR36057_MCTCR_CFlush;
1662         btwrite(reg, ZR36057_MCTCR);
1663
1664         /* deassert P_Reset */
1665         btwrite(ZR36057_JPC_P_Reset, ZR36057_JPC);
1666 }
1667
1668 static void zr36057_enable_jpg(struct zoran *zr, enum zoran_codec_mode mode)
1669 {
1670         static int zero = 0;
1671         static int one = 1;
1672
1673         switch (mode) {
1674
1675         case BUZ_MODE_MOTION_COMPRESS:
1676                 zr36060_set_cap(zr, mode);
1677                 zr36057_set_jpg(zr, mode);
1678                 i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_ENABLE_OUTPUT, &one);
1679                 i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEOENCODER, ENCODER_SET_INPUT, &zero);
1680
1681                 /* deassert P_Reset, assert Code transfer enable */
1682                 btwrite(IRQ_MASK, ZR36057_ISR);
1683                 btand(~ZR36057_MCTCR_CFlush, ZR36057_MCTCR);
1684                 break;
1685
1686         case BUZ_MODE_MOTION_DECOMPRESS:
1687                 i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_ENABLE_OUTPUT, &zero);
1688                 i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEOENCODER, ENCODER_SET_INPUT, &one);
1689                 zr36060_set_cap(zr, mode);
1690                 zr36057_set_jpg(zr, mode);
1691
1692                 /* deassert P_Reset, assert Code transfer enable */
1693                 btwrite(IRQ_MASK, ZR36057_ISR);
1694                 btand(~ZR36057_MCTCR_CFlush, ZR36057_MCTCR);
1695                 break;
1696
1697         case BUZ_MODE_IDLE:
1698         default:
1699                 /* shut down processing */
1700                 btor(ZR36057_MCTCR_CFlush, ZR36057_MCTCR);
1701                 btwrite(ZR36057_JPC_P_Reset, ZR36057_JPC);
1702                 btand(~ZR36057_JMC_VFIFO_FB, ZR36057_JMC);
1703                 btand(~ZR36057_JMC_SyncMstr, ZR36057_JMC);
1704                 btand(~ZR36057_JMC_Go_en, ZR36057_JMC);
1705                 btwrite(0, ZR36057_ISR);
1706                 zr36060_reset(zr);
1707                 i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_ENABLE_OUTPUT, &one);
1708                 i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEOENCODER, ENCODER_SET_INPUT, &zero);
1709                 break;
1710
1711         }
1712         zr->codec_mode = mode;
1713 }
1714
1715 /*
1716  *   Queue a MJPEG buffer for capture/playback
1717  */
1718
1719 static int jpg_qbuf(struct zoran *zr, int frame, enum zoran_codec_mode mode)
1720 {
1721         unsigned long flags;
1722         int res;
1723
1724         /* Check if buffers are allocated */
1725
1726         if (!zr->jpg_buffers_allocated) {
1727                 printk(KERN_ERR "%s: jpg_qbuf: buffers not yet allocated\n", zr->name);
1728                 return -ENOMEM;
1729         }
1730         /* Does the user want to stop streaming? */
1731
1732         if (frame < 0) {
1733                 if (zr->codec_mode == mode) {
1734                         zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
1735                         return 0;
1736                 } else {
1737                         printk(KERN_ERR "%s: jpg_qbuf - stop streaming but not in streaming mode\n", zr->name);
1738                         return -EINVAL;
1739                 }
1740         }
1741         /* No grabbing outside the buffer range! */
1742
1743         if (frame >= zr->jpg_nbufs) {
1744                 printk(KERN_ERR "%s: jpg_qbuf: buffer %d out of range\n", zr->name, frame);
1745                 return -EINVAL;
1746         }
1747         /* what is the codec mode right now? */
1748
1749         if (zr->codec_mode == BUZ_MODE_IDLE) {
1750                 /* Ok load up the zr36060 and go */
1751                 zr36057_enable_jpg(zr, mode);
1752         } else if (zr->codec_mode != mode) {
1753                 /* wrong codec mode active - invalid */
1754                 printk(KERN_ERR "%s: jpg_qbuf - codec in wrong mode\n", zr->name);
1755                 return -EINVAL;
1756         }
1757         spin_lock_irqsave(&zr->lock, flags);
1758
1759         /* make sure a grab isn't going on currently with this buffer */
1760
1761         switch (zr->jpg_gbuf[frame].state) {
1762
1763         default:
1764         case BUZ_STATE_DMA:
1765         case BUZ_STATE_PEND:
1766         case BUZ_STATE_DONE:
1767                 res = -EBUSY;   /* what are you doing? */
1768                 break;
1769
1770         case BUZ_STATE_USER:
1771                 /* since there is at least one unused buffer there's room for at least one more pend[] entry */
1772                 zr->jpg_pend[zr->jpg_que_head++ & BUZ_MASK_FRAME] = frame;
1773                 zr->jpg_gbuf[frame].state = BUZ_STATE_PEND;
1774                 zoran_feed_stat_com(zr);
1775                 res = 0;
1776                 break;
1777
1778         }
1779
1780         spin_unlock_irqrestore(&zr->lock, flags);
1781
1782         /* Start the zr36060 when the first frame is queued  */
1783         if (zr->jpg_que_head == 1) {
1784                 btor(ZR36057_JMC_Go_en, ZR36057_JMC);
1785                 btwrite(ZR36057_JPC_P_Reset | ZR36057_JPC_CodTrnsEn | ZR36057_JPC_Active, ZR36057_JPC);
1786         }
1787         return res;
1788 }
1789
1790 /*
1791  *   Sync on a MJPEG buffer
1792  */
1793
1794 static int jpg_sync(struct zoran *zr, struct zoran_sync *bs)
1795 {
1796         unsigned long flags;
1797         int frame;
1798
1799         if (zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS &&
1800             zr->codec_mode != BUZ_MODE_MOTION_COMPRESS) {
1801                 return -EINVAL;
1802         }
1803         while (zr->jpg_que_tail == zr->jpg_dma_tail) {
1804                 interruptible_sleep_on(&zr->jpg_capq);
1805                 if (signal_pending(current))
1806                         return -ERESTARTSYS;
1807         }
1808
1809         spin_lock_irqsave(&zr->lock, flags);
1810
1811         frame = zr->jpg_pend[zr->jpg_que_tail++ & BUZ_MASK_FRAME];
1812
1813         /* buffer should now be in BUZ_STATE_DONE */
1814
1815         if (zr->jpg_gbuf[frame].state != BUZ_STATE_DONE)
1816                 printk(KERN_ERR "%s: jpg_sync - internal error\n", zr->name);
1817
1818         *bs = zr->jpg_gbuf[frame].bs;
1819         zr->jpg_gbuf[frame].state = BUZ_STATE_USER;
1820
1821         spin_unlock_irqrestore(&zr->lock, flags);
1822
1823         return 0;
1824 }
1825
1826 /* when this is called the spinlock must be held */
1827 static void zoran_feed_stat_com(struct zoran *zr)
1828 {
1829         /* move frames from pending queue to DMA */
1830
1831         int frame, i, max_stat_com;
1832
1833         max_stat_com = (zr->params.TmpDcm == 1) ? BUZ_NUM_STAT_COM : (BUZ_NUM_STAT_COM >> 1);
1834
1835         while ((zr->jpg_dma_head - zr->jpg_dma_tail) < max_stat_com
1836                && zr->jpg_dma_head != zr->jpg_que_head) {
1837
1838                 frame = zr->jpg_pend[zr->jpg_dma_head & BUZ_MASK_FRAME];
1839                 if (zr->params.TmpDcm == 1) {
1840                         /* fill 1 stat_com entry */
1841                         i = zr->jpg_dma_head & BUZ_MASK_STAT_COM;
1842                         zr->stat_com[i] = zr->jpg_gbuf[frame].frag_tab_bus;
1843                 } else {
1844                         /* fill 2 stat_com entries */
1845                         i = (zr->jpg_dma_head & 1) * 2;
1846                         zr->stat_com[i] = zr->jpg_gbuf[frame].frag_tab_bus;
1847                         zr->stat_com[i + 1] = zr->jpg_gbuf[frame].frag_tab_bus;
1848                 }
1849                 zr->jpg_gbuf[frame].state = BUZ_STATE_DMA;
1850                 zr->jpg_dma_head++;
1851
1852         }
1853 }
1854
1855 /* when this is called the spinlock must be held */
1856 static void zoran_reap_stat_com(struct zoran *zr)
1857 {
1858         /* move frames from DMA queue to done queue */
1859
1860         int i;
1861         u32 stat_com;
1862         unsigned int seq;
1863         unsigned int dif;
1864         int frame;
1865         struct zoran_gbuffer *gbuf;
1866
1867         /* In motion decompress we don't have a hardware frame counter,
1868            we just count the interrupts here */
1869
1870         if (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS)
1871                 zr->jpg_seq_num++;
1872
1873         while (zr->jpg_dma_tail != zr->jpg_dma_head) {
1874                 if (zr->params.TmpDcm == 1)
1875                         i = zr->jpg_dma_tail & BUZ_MASK_STAT_COM;
1876                 else
1877                         i = (zr->jpg_dma_tail & 1) * 2 + 1;
1878
1879                 stat_com = zr->stat_com[i];
1880
1881                 if ((stat_com & 1) == 0) {
1882                         return;
1883                 }
1884                 frame = zr->jpg_pend[zr->jpg_dma_tail & BUZ_MASK_FRAME];
1885                 gbuf = &zr->jpg_gbuf[frame];
1886                 get_fast_time(&gbuf->bs.timestamp);
1887
1888                 if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
1889                         gbuf->bs.length = (stat_com & 0x7fffff) >> 1;
1890
1891                         /* update sequence number with the help of the counter in stat_com */
1892
1893                         seq = stat_com >> 24;
1894                         dif = (seq - zr->jpg_seq_num) & 0xff;
1895                         zr->jpg_seq_num += dif;
1896                 } else {
1897                         gbuf->bs.length = 0;
1898                 }
1899                 gbuf->bs.seq = zr->params.TmpDcm == 2 ? (zr->jpg_seq_num >> 1) : zr->jpg_seq_num;
1900                 gbuf->state = BUZ_STATE_DONE;
1901
1902                 zr->jpg_dma_tail++;
1903         }
1904 }
1905
1906 static void zoran_irq(int irq, void *dev_id, struct pt_regs *regs)
1907 {
1908         u32 stat, astat;
1909         int count;
1910         struct zoran *zr;
1911         unsigned long flags;
1912
1913         zr = (struct zoran *) dev_id;
1914         count = 0;
1915
1916         spin_lock_irqsave(&zr->lock, flags);
1917         while (1) {
1918                 /* get/clear interrupt status bits */
1919                 stat = btread(ZR36057_ISR);
1920                 astat = stat & IRQ_MASK;
1921                 if (!astat) {
1922                         break;
1923                 }
1924                 btwrite(astat, ZR36057_ISR);
1925                 IDEBUG(printk(BUZ_DEBUG "-%u: astat %08x stat %08x\n", zr->id, astat, stat));
1926
1927 #if (IRQ_MASK & ZR36057_ISR_GIRQ0)
1928                 if (astat & ZR36057_ISR_GIRQ0) {
1929
1930                         /* Interrupts may still happen when zr->v4l_memgrab_active is switched off.
1931                            We simply ignore them */
1932
1933                         if (zr->v4l_memgrab_active) {
1934
1935 /* A lot more checks should be here ... */
1936                                 if ((btread(ZR36057_VSSFGR) & ZR36057_VSSFGR_SnapShot) == 0)
1937                                         printk(KERN_WARNING "%s: BuzIRQ with SnapShot off ???\n", zr->name);
1938
1939                                 if (zr->v4l_grab_frame != NO_GRAB_ACTIVE) {
1940                                         /* There is a grab on a frame going on, check if it has finished */
1941
1942                                         if ((btread(ZR36057_VSSFGR) & ZR36057_VSSFGR_FrameGrab) == 0) {
1943                                                 /* it is finished, notify the user */
1944
1945                                                 zr->v4l_gbuf[zr->v4l_grab_frame].state = BUZ_STATE_DONE;
1946                                                 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
1947                                                 zr->v4l_grab_seq++;
1948                                                 zr->v4l_pend_tail++;
1949                                         }
1950                                 }
1951                                 if (zr->v4l_grab_frame == NO_GRAB_ACTIVE)
1952                                         wake_up_interruptible(&zr->v4l_capq);
1953
1954                                 /* Check if there is another grab queued */
1955
1956                                 if (zr->v4l_grab_frame == NO_GRAB_ACTIVE &&
1957                                     zr->v4l_pend_tail != zr->v4l_pend_head) {
1958
1959                                         int frame = zr->v4l_pend[zr->v4l_pend_tail & V4L_MASK_FRAME];
1960                                         u32 reg;
1961
1962                                         zr->v4l_grab_frame = frame;
1963
1964                                         /* Set zr36057 video front end and enable video */
1965
1966                                         /* Buffer address */
1967
1968                                         reg = zr->v4l_gbuf[frame].fbuffer_bus;
1969                                         btwrite(reg, ZR36057_VDTR);
1970                                         if (zr->video_interlace)
1971                                                 reg += zr->gbpl;
1972                                         btwrite(reg, ZR36057_VDBR);
1973
1974                                         /* video stride, status, and frame grab register */
1975
1976 #ifdef XAWTV_HACK
1977                                         reg = (zr->gwidth > 720) ? ((zr->gwidth & ~3) - 720) * zr->gbpl / zr->gwidth : 0;
1978 #else
1979                                         reg = 0;
1980 #endif
1981                                         if (zr->video_interlace)
1982                                                 reg += zr->gbpl;
1983                                         reg = (reg << ZR36057_VSSFGR_DispStride);
1984                                         reg |= ZR36057_VSSFGR_VidOvf;
1985                                         reg |= ZR36057_VSSFGR_SnapShot;
1986                                         reg |= ZR36057_VSSFGR_FrameGrab;
1987                                         btwrite(reg, ZR36057_VSSFGR);
1988
1989                                         btor(ZR36057_VDCR_VidEn, ZR36057_VDCR);
1990                                 }
1991                         }
1992                 }
1993 #endif                          /* (IRQ_MASK & ZR36057_ISR_GIRQ0) */
1994
1995 #if (IRQ_MASK & ZR36057_ISR_GIRQ1)
1996                 if (astat & ZR36057_ISR_GIRQ1) {
1997                         unsigned csr = zr36060_read_8(zr, 0x001);
1998                         unsigned isr = zr36060_read_8(zr, 0x008);
1999
2000                         IDEBUG(printk(KERN_DEBUG "%s: ZR36057_ISR_GIRQ1 60_code=%02x 60_intr=%02x\n",
2001                                       zr->name, csr, isr));
2002
2003                         btand(~ZR36057_ICR_GIRQ1, ZR36057_ICR);
2004                         zoran_reap_stat_com(zr);
2005                         zoran_feed_stat_com(zr);
2006                 }
2007 #endif                          /* (IRQ_MASK & ZR36057_ISR_GIRQ1) */
2008
2009 #if (IRQ_MASK & ZR36057_ISR_CodRepIRQ)
2010                 if (astat & ZR36057_ISR_CodRepIRQ) {
2011                         IDEBUG(printk(KERN_DEBUG "%s: ZR36057_ISR_CodRepIRQ\n", zr->name));
2012                         btand(~ZR36057_ICR_CodRepIRQ, ZR36057_ICR);
2013                 }
2014 #endif                          /* (IRQ_MASK & ZR36057_ISR_CodRepIRQ) */
2015
2016 #if (IRQ_MASK & ZR36057_ISR_JPEGRepIRQ)
2017                 if ((astat & ZR36057_ISR_JPEGRepIRQ) &&
2018                     (zr->codec_mode == BUZ_MODE_MOTION_DECOMPRESS ||
2019                      zr->codec_mode == BUZ_MODE_MOTION_COMPRESS)) {
2020                         zoran_reap_stat_com(zr);
2021                         zoran_feed_stat_com(zr);
2022                         wake_up_interruptible(&zr->jpg_capq);
2023                 }
2024 #endif                          /* (IRQ_MASK & ZR36057_ISR_JPEGRepIRQ) */
2025
2026                 count++;
2027                 if (count > 10) {
2028                         printk(KERN_WARNING "%s: irq loop %d\n", zr->name, count);
2029                         if (count > 20) {
2030                                 btwrite(0, ZR36057_ICR);
2031                                 printk(KERN_ERR  "%s: IRQ lockup, cleared int mask\n", zr->name);
2032                                 break;
2033                         }
2034                 }
2035         }
2036         spin_unlock_irqrestore(&zr->lock, flags);
2037 }
2038
2039 /* Check a zoran_params struct for correctness, insert default params */
2040
2041 static int zoran_check_params(struct zoran *zr, struct zoran_params *params)
2042 {
2043         int err = 0, err0 = 0;
2044
2045         /* insert constant params */
2046
2047         params->major_version = MAJOR_VERSION;
2048         params->minor_version = MINOR_VERSION;
2049
2050         /* Check input and norm */
2051
2052         if (params->input != 0 && params->input != 1) {
2053                 err++;
2054         }
2055         if (params->norm != VIDEO_MODE_PAL && params->norm != VIDEO_MODE_NTSC) {
2056                 err++;
2057         }
2058         /* Check decimation, set default values for decimation = 1, 2, 4 */
2059
2060         switch (params->decimation) {
2061         case 1:
2062
2063                 params->HorDcm = 1;
2064                 params->VerDcm = 1;
2065                 params->TmpDcm = 1;
2066                 params->field_per_buff = 2;
2067
2068                 params->img_x = 0;
2069                 params->img_y = 0;
2070                 params->img_width = 720;
2071                 params->img_height = tvnorms[params->norm].Ha / 2;
2072                 break;
2073
2074         case 2:
2075
2076                 params->HorDcm = 2;
2077                 params->VerDcm = 1;
2078                 params->TmpDcm = 2;
2079                 params->field_per_buff = 1;
2080
2081                 params->img_x = 8;
2082                 params->img_y = 0;
2083                 params->img_width = 704;
2084                 params->img_height = tvnorms[params->norm].Ha / 2;
2085                 break;
2086
2087         case 4:
2088
2089                 params->HorDcm = 4;
2090                 params->VerDcm = 2;
2091                 params->TmpDcm = 2;
2092                 params->field_per_buff = 1;
2093
2094                 params->img_x = 8;
2095                 params->img_y = 0;
2096                 params->img_width = 704;
2097                 params->img_height = tvnorms[params->norm].Ha / 2;
2098                 break;
2099
2100         case 0:
2101
2102                 /* We have to check the data the user has set */
2103
2104                 if (params->HorDcm != 1 && params->HorDcm != 2 && params->HorDcm != 4)
2105                         err0++;
2106                 if (params->VerDcm != 1 && params->VerDcm != 2)
2107                         err0++;
2108                 if (params->TmpDcm != 1 && params->TmpDcm != 2)
2109                         err0++;
2110                 if (params->field_per_buff != 1 && params->field_per_buff != 2)
2111                         err0++;
2112
2113                 if (params->img_x < 0)
2114                         err0++;
2115                 if (params->img_y < 0)
2116                         err0++;
2117                 if (params->img_width < 0)
2118                         err0++;
2119                 if (params->img_height < 0)
2120                         err0++;
2121                 if (params->img_x + params->img_width > 720)
2122                         err0++;
2123                 if (params->img_y + params->img_height > tvnorms[params->norm].Ha / 2)
2124                         err0++;
2125                 if (params->img_width % (16 * params->HorDcm) != 0)
2126                         err0++;
2127                 if (params->img_height % (8 * params->VerDcm) != 0)
2128                         err0++;
2129
2130                 if (err0) {
2131                         err++;
2132                 }
2133                 break;
2134
2135         default:
2136                 err++;
2137                 break;
2138         }
2139
2140         if (params->quality > 100)
2141                 params->quality = 100;
2142         if (params->quality < 5)
2143                 params->quality = 5;
2144
2145         if (params->APPn < 0)
2146                 params->APPn = 0;
2147         if (params->APPn > 15)
2148                 params->APPn = 15;
2149         if (params->APP_len < 0)
2150                 params->APP_len = 0;
2151         if (params->APP_len > 60)
2152                 params->APP_len = 60;
2153         if (params->COM_len < 0)
2154                 params->COM_len = 0;
2155         if (params->COM_len > 60)
2156                 params->COM_len = 60;
2157
2158         if (err)
2159                 return -EINVAL;
2160
2161         return 0;
2162
2163 }
2164 static void zoran_open_init_params(struct zoran *zr)
2165 {
2166         int i;
2167
2168         /* Per default, map the V4L Buffers */
2169
2170         zr->map_mjpeg_buffers = 0;
2171
2172         /* User must explicitly set a window */
2173
2174         zr->window_set = 0;
2175
2176         zr->window.x = 0;
2177         zr->window.y = 0;
2178         zr->window.width = 0;
2179         zr->window.height = 0;
2180         zr->window.chromakey = 0;
2181         zr->window.flags = 0;
2182         zr->window.clips = NULL;
2183         zr->window.clipcount = 0;
2184
2185         zr->video_interlace = 0;
2186
2187         zr->v4l_memgrab_active = 0;
2188         zr->v4l_overlay_active = 0;
2189
2190         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
2191         zr->v4l_grab_seq = 0;
2192
2193         zr->gwidth = 0;
2194         zr->gheight = 0;
2195         zr->gformat = 0;
2196         zr->gbpl = 0;
2197
2198         /* DMA ring stuff for V4L */
2199
2200         zr->v4l_pend_tail = 0;
2201         zr->v4l_pend_head = 0;
2202         for (i = 0; i < v4l_nbufs; i++) {
2203                 zr->v4l_gbuf[i].state = BUZ_STATE_USER; /* nothing going on */
2204         }
2205
2206         /* Set necessary params and call zoran_check_params to set the defaults */
2207
2208         zr->params.decimation = 1;
2209
2210         zr->params.quality = 50;        /* default compression factor 8 */
2211         zr->params.odd_even = 1;
2212
2213         zr->params.APPn = 0;
2214         zr->params.APP_len = 0; /* No APPn marker */
2215         for (i = 0; i < 60; i++)
2216                 zr->params.APP_data[i] = 0;
2217
2218         zr->params.COM_len = 0; /* No COM marker */
2219         for (i = 0; i < 60; i++)
2220                 zr->params.COM_data[i] = 0;
2221
2222         zr->params.VFIFO_FB = 0;
2223
2224         memset(zr->params.reserved, 0, sizeof(zr->params.reserved));
2225
2226         zr->params.jpeg_markers = JPEG_MARKER_DHT | JPEG_MARKER_DQT;
2227
2228         i = zoran_check_params(zr, &zr->params);
2229         if (i)
2230                 printk(KERN_ERR "%s: zoran_open_init_params internal error\n", zr->name);
2231 }
2232
2233 /*
2234  *   Open a buz card. Right now the flags stuff is just playing
2235  */
2236
2237 static int zoran_open(struct video_device *dev, int flags)
2238 {
2239         struct zoran *zr = (struct zoran *) dev;
2240
2241         DEBUG(printk(KERN_INFO ": zoran_open\n"));
2242
2243         switch (flags) {
2244
2245         case 0:
2246                 if (zr->user)
2247                         return -EBUSY;
2248                 zr->user++;
2249
2250                 if (v4l_fbuffer_alloc(zr) < 0) {
2251                         zr->user--;
2252                         return -ENOMEM;
2253                 }
2254                 /* default setup */
2255
2256                 zoran_open_init_params(zr);
2257
2258                 zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
2259
2260                 btwrite(IRQ_MASK, ZR36057_ISR);         // Clears interrupts
2261
2262                 btor(ZR36057_ICR_IntPinEn, ZR36057_ICR);
2263
2264                 break;
2265
2266         default:
2267                 return -EBUSY;
2268
2269         }
2270         MOD_INC_USE_COUNT;
2271         return 0;
2272 }
2273
2274 static void zoran_close(struct video_device *dev)
2275 {
2276         struct zoran *zr = (struct zoran *) dev;
2277
2278         DEBUG(printk(KERN_INFO ": zoran_close\n"));
2279
2280         /* disable interrupts */
2281         btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);
2282
2283         /* wake up sleeping beauties */
2284         wake_up_interruptible(&zr->v4l_capq);
2285         wake_up_interruptible(&zr->jpg_capq);
2286
2287         zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
2288         zr36057_set_memgrab(zr, 0);
2289         if (zr->v4l_overlay_active)
2290                 zr36057_overlay(zr, 0);
2291
2292         zr->user--;
2293
2294         v4l_fbuffer_free(zr);
2295         jpg_fbuffer_free(zr);
2296         zr->jpg_nbufs = 0;
2297
2298         MOD_DEC_USE_COUNT;
2299         DEBUG(printk(KERN_INFO ": zoran_close done\n"));
2300 }
2301
2302
2303 static long zoran_read(struct video_device *dev, char *buf, unsigned long count, int nonblock)
2304 {
2305         return -EINVAL;
2306 }
2307
2308 static long zoran_write(struct video_device *dev, const char *buf, unsigned long count, int nonblock)
2309 {
2310         return -EINVAL;
2311 }
2312
2313 /*
2314  *   ioctl routine
2315  */
2316
2317
2318 static int zoran_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
2319 {
2320         struct zoran *zr = (struct zoran *) dev;
2321
2322         switch (cmd) {
2323
2324         case VIDIOCGCAP:
2325                 {
2326                         struct video_capability b;
2327                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGCAP\n"));
2328                         strncpy(b.name, zr->video_dev.name, sizeof(b.name));
2329                         b.type = VID_TYPE_CAPTURE |
2330                             VID_TYPE_OVERLAY |
2331                             VID_TYPE_CLIPPING |
2332                             VID_TYPE_FRAMERAM |
2333                             VID_TYPE_SCALES;
2334                         /* theoretically we could also flag VID_TYPE_SUBCAPTURE
2335                            but this is not even implemented in the BTTV driver */
2336
2337                         b.channels = 2;         /* composite, svhs */
2338                         b.audios = 0;
2339                         b.maxwidth = BUZ_MAX_WIDTH;
2340                         b.maxheight = BUZ_MAX_HEIGHT;
2341                         b.minwidth = BUZ_MIN_WIDTH;
2342                         b.minheight = BUZ_MIN_HEIGHT;
2343                         if (copy_to_user(arg, &b, sizeof(b))) {
2344                                 return -EFAULT;
2345                         }
2346                         return 0;
2347                 }
2348
2349         case VIDIOCGCHAN:
2350                 {
2351                         struct video_channel v;
2352
2353                         if (copy_from_user(&v, arg, sizeof(v))) {
2354                                 return -EFAULT;
2355                         }
2356                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGCHAN for channel %d\n", v.channel));
2357                         switch (v.channel) {
2358                         case 0:
2359                                 strcpy(v.name, "Composite");
2360                                 break;
2361                         case 1:
2362                                 strcpy(v.name, "SVHS");
2363                                 break;
2364                         default:
2365                                 return -EINVAL;
2366                         }
2367                         v.tuners = 0;
2368                         v.flags = 0;
2369                         v.type = VIDEO_TYPE_CAMERA;
2370                         v.norm = zr->params.norm;
2371                         if (copy_to_user(arg, &v, sizeof(v))) {
2372                                 return -EFAULT;
2373                         }
2374                         return 0;
2375                 }
2376
2377                 /* RJ: the documentation at http://roadrunner.swansea.linux.org.uk/v4lapi.shtml says:
2378
2379                  * "The VIDIOCSCHAN ioctl takes an integer argument and switches the capture to this input."
2380                  *                                 ^^^^^^^
2381                  * The famos BTTV driver has it implemented with a struct video_channel argument
2382                  * and we follow it for compatibility reasons
2383                  *
2384                  * BTW: this is the only way the user can set the norm!
2385                  */
2386
2387         case VIDIOCSCHAN:
2388                 {
2389                         struct video_channel v;
2390                         int input;
2391                         int on, res;
2392
2393                         if (copy_from_user(&v, arg, sizeof(v))) {
2394                                 return -EFAULT;
2395                         }
2396                         IOCTL_DEBUG(printk("buz ioctl VIDIOCSCHAN: channel=%d, norm=%d\n", v.channel, v.norm));
2397                         switch (v.channel) {
2398                         case 0:
2399                                 input = 3;
2400                                 break;
2401                         case 1:
2402                                 input = 7;
2403                                 break;
2404                         default:
2405                                 return -EINVAL;
2406                         }
2407
2408                         if (v.norm != VIDEO_MODE_PAL
2409                             && v.norm != VIDEO_MODE_NTSC) {
2410                                 return -EINVAL;
2411                         }
2412                         zr->params.norm = v.norm;
2413                         zr->params.input = v.channel;
2414
2415                         /* We switch overlay off and on since a change in the norm
2416                            needs different VFE settings */
2417
2418                         on = zr->v4l_overlay_active && !zr->v4l_memgrab_active;
2419                         if (on)
2420                                 zr36057_overlay(zr, 0);
2421
2422                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &input);
2423                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &zr->params.norm);
2424                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEOENCODER, ENCODER_SET_NORM, &zr->params.norm);
2425
2426                         if (on)
2427                                 zr36057_overlay(zr, 1);
2428
2429                         /* Make sure the changes come into effect */
2430                         res = wait_grab_pending(zr);
2431                         if (res)
2432                                 return res;
2433
2434                         return 0;
2435                 }
2436
2437         case VIDIOCGTUNER:
2438         case VIDIOCSTUNER:
2439                         return -EINVAL;
2440
2441         case VIDIOCGPICT:
2442                 {
2443                         struct video_picture p = zr->picture;
2444
2445                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGPICT\n"));
2446                         p.depth = zr->buffer.depth;
2447                         switch (zr->buffer.depth) {
2448                         case 15:
2449                                 p.palette = VIDEO_PALETTE_RGB555;
2450                                 break;
2451
2452                         case 16:
2453                                 p.palette = VIDEO_PALETTE_RGB565;
2454                                 break;
2455
2456                         case 24:
2457                                 p.palette = VIDEO_PALETTE_RGB24;
2458                                 break;
2459
2460                         case 32:
2461                                 p.palette = VIDEO_PALETTE_RGB32;
2462                                 break;
2463                         }
2464
2465                         if (copy_to_user(arg, &p, sizeof(p))) {
2466                                 return -EFAULT;
2467                         }
2468                         return 0;
2469                 }
2470
2471         case VIDIOCSPICT:
2472                 {
2473                         struct video_picture p;
2474
2475                         if (copy_from_user(&p, arg, sizeof(p))) {
2476                                 return -EFAULT;
2477                         }
2478                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_PICTURE, &p);
2479                         IOCTL_DEBUG(printk("buz ioctl VIDIOCSPICT bri=%d hue=%d col=%d con=%d dep=%d pal=%d\n",
2480                                            p.brightness, p.hue, p.colour, p.contrast, p.depth, p.palette));
2481                         /* The depth and palette values have no meaning to us,
2482                            should we return  -EINVAL if they don't fit ? */
2483                         zr->picture = p;
2484                         return 0;
2485                 }
2486
2487         case VIDIOCCAPTURE:
2488                 {
2489                         int v, res;
2490
2491                         if (copy_from_user(&v, arg, sizeof(v))) {
2492                                 return -EFAULT;
2493                         }
2494                         IOCTL_DEBUG(printk("buz ioctl VIDIOCCAPTURE: %d\n", v));
2495                         /* If there is nothing to do, return immediatly */
2496
2497                         if ((v && zr->v4l_overlay_active) || (!v && !zr->v4l_overlay_active))
2498                                 return 0;
2499
2500                         if (v == 0) {
2501                                 zr->v4l_overlay_active = 0;
2502                                 if (!zr->v4l_memgrab_active)
2503                                         zr36057_overlay(zr, 0);
2504                                 /* When a grab is running, the video simply won't be switched on any more */
2505                         } else {
2506                                 if (!zr->buffer_set || !zr->window_set) {
2507                                         return -EINVAL;
2508                                 }
2509                                 zr->v4l_overlay_active = 1;
2510                                 if (!zr->v4l_memgrab_active)
2511                                         zr36057_overlay(zr, 1);
2512                                 /* When a grab is running, the video will be switched on when grab is finished */
2513                         }
2514                         /* Make sure the changes come into effect */
2515                         res = wait_grab_pending(zr);
2516                         if (res)
2517                                 return res;
2518                         return 0;
2519                 }
2520
2521         case VIDIOCGWIN:
2522                 {
2523                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGWIN\n"));
2524                         if (copy_to_user(arg, &zr->window, sizeof(zr->window))) {
2525                                 return -EFAULT;
2526                         }
2527                         return 0;
2528                 }
2529
2530         case VIDIOCSWIN:
2531                 {
2532                         struct video_clip *vcp;
2533                         struct video_window vw;
2534                         int on, end, res;
2535
2536                         if (copy_from_user(&vw, arg, sizeof(vw))) {
2537                                 return -EFAULT;
2538                         }
2539                         IOCTL_DEBUG(printk("buz ioctl VIDIOCSWIN: x=%d y=%d w=%d h=%d clipcount=%d\n", vw.x, vw.y, vw.width, vw.height, vw.clipcount));
2540                         if (!zr->buffer_set) {
2541                                 return -EINVAL;
2542                         }
2543                         /*
2544                          * The video front end needs 4-byte alinged line sizes, we correct that
2545                          * silently here if necessary
2546                          */
2547
2548                         if (zr->buffer.depth == 15 || zr->buffer.depth == 16) {
2549                                 end = (vw.x + vw.width) & ~1;   /* round down */
2550                                 vw.x = (vw.x + 1) & ~1;         /* round up */
2551                                 vw.width = end - vw.x;
2552                         }
2553                         if (zr->buffer.depth == 24) {
2554                                 end = (vw.x + vw.width) & ~3;   /* round down */
2555                                 vw.x = (vw.x + 3) & ~3;         /* round up */
2556                                 vw.width = end - vw.x;
2557                         }
2558 #if 0
2559                         // At least xawtv seems to care about the following - just leave it away
2560                         /*
2561                          * Also corrected silently (as long as window fits at all):
2562                          * video not fitting the screen
2563                          */
2564 #if 0
2565                         if (vw.x < 0 || vw.y < 0 || vw.x + vw.width > zr->buffer.width ||
2566                             vw.y + vw.height > zr->buffer.height) {
2567                                 printk(BUZ_ERR ": VIDIOCSWIN: window does not fit frame buffer: %dx%d+%d*%d\n",
2568                                        vw.width, vw.height, vw.x, vw.y);
2569                                 return -EINVAL;
2570                         }
2571 #else
2572                         if (vw.x < 0)
2573                                 vw.x = 0;
2574                         if (vw.y < 0)
2575                                 vw.y = 0;
2576                         if (vw.x + vw.width > zr->buffer.width)
2577                                 vw.width = zr->buffer.width - vw.x;
2578                         if (vw.y + vw.height > zr->buffer.height)
2579                                 vw.height = zr->buffer.height - vw.y;
2580 #endif
2581 #endif
2582
2583                         /* Check for vaild parameters */
2584                         if (vw.width < BUZ_MIN_WIDTH || vw.height < BUZ_MIN_HEIGHT ||
2585                             vw.width > BUZ_MAX_WIDTH || vw.height > BUZ_MAX_HEIGHT) {
2586                                 return -EINVAL;
2587                         }
2588 #ifdef XAWTV_HACK
2589                         if (vw.width > 720)
2590                                 vw.width = 720;
2591 #endif
2592
2593                         zr->window.x = vw.x;
2594                         zr->window.y = vw.y;
2595                         zr->window.width = vw.width;
2596                         zr->window.height = vw.height;
2597                         zr->window.chromakey = 0;
2598                         zr->window.flags = 0;   // RJ: Is this intended for interlace on/off ?
2599
2600                         zr->window.clips = NULL;
2601                         zr->window.clipcount = vw.clipcount;
2602
2603                         /*
2604                          * If an overlay is running, we have to switch it off
2605                          * and switch it on again in order to get the new settings in effect.
2606                          *
2607                          * We also want to avoid that the overlay mask is written
2608                          * when an overlay is running.
2609                          */
2610
2611                         on = zr->v4l_overlay_active && !zr->v4l_memgrab_active;
2612                         if (on)
2613                                 zr36057_overlay(zr, 0);
2614
2615                         /*
2616                          *   Write the overlay mask if clips are wanted.
2617                          */
2618                         if (vw.clipcount) {
2619                                 vcp = vmalloc(sizeof(struct video_clip) * (vw.clipcount + 4));
2620                                 if (vcp == NULL) {
2621                                         return -ENOMEM;
2622                                 }
2623                                 if (copy_from_user(vcp, vw.clips, sizeof(struct video_clip) * vw.clipcount)) {
2624                                         vfree(vcp);
2625                                         return -EFAULT;
2626                                 }
2627                                 write_overlay_mask(zr, vcp, vw.clipcount);
2628                                 vfree(vcp);
2629                         }
2630                         if (on)
2631                                 zr36057_overlay(zr, 1);
2632                         zr->window_set = 1;
2633
2634                         /* Make sure the changes come into effect */
2635                         res = wait_grab_pending(zr);
2636                         if (res)
2637                                 return res;
2638
2639                         return 0;
2640                 }
2641
2642         case VIDIOCGFBUF:
2643                 {
2644                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGFBUF\n"));
2645                         if (copy_to_user(arg, &zr->buffer, sizeof(zr->buffer))) {
2646                                 return -EFAULT;
2647                         }
2648                         return 0;
2649                 }
2650
2651         case VIDIOCSFBUF:
2652                 {
2653                         struct video_buffer v;
2654
2655                         if (!capable(CAP_SYS_ADMIN)
2656                         || !capable(CAP_SYS_RAWIO))
2657                                 return -EPERM;
2658
2659                         if (copy_from_user(&v, arg, sizeof(v)))
2660                                 return -EFAULT;
2661
2662                         IOCTL_DEBUG(printk("buz ioctl VIDIOCSFBUF: base=0x%x w=%d h=%d depth=%d bpl=%d\n", (u32) v.base, v.width, v.height, v.depth, v.bytesperline));
2663                         if (zr->v4l_overlay_active) {
2664                                 /* Has the user gotten crazy ... ? */
2665                                 return -EINVAL;
2666                         }
2667                         if (v.depth != 15
2668                             && v.depth != 16
2669                             && v.depth != 24
2670                             && v.depth != 32) {
2671                                 return -EINVAL;
2672                         }
2673                         if (v.height <= 0 || v.width <= 0 || v.bytesperline <= 0) {
2674                                 return -EINVAL;
2675                         }
2676                         if (v.bytesperline & 3) {
2677                                 return -EINVAL;
2678                         }
2679                         if (v.base) {
2680                                 zr->buffer.base = (void *) ((unsigned long) v.base & ~3);
2681                         }
2682                         zr->buffer.height = v.height;
2683                         zr->buffer.width = v.width;
2684                         zr->buffer.depth = v.depth;
2685                         zr->buffer.bytesperline = v.bytesperline;
2686
2687                         if (zr->buffer.base)
2688                                 zr->buffer_set = 1;
2689                         zr->window_set = 0;     /* The user should set new window parameters */
2690                         return 0;
2691                 }
2692
2693                 /* RJ: what is VIDIOCKEY intended to do ??? */
2694
2695         case VIDIOCGFREQ:
2696         case VIDIOCSFREQ:
2697         case VIDIOCGAUDIO:
2698         case VIDIOCSAUDIO:
2699                 return -EINVAL;
2700
2701         case VIDIOCSYNC:
2702                 {
2703                         int v;
2704
2705                         if (copy_from_user(&v, arg, sizeof(v))) {
2706                                 return -EFAULT;
2707                         }
2708                         IOCTL_DEBUG(printk("buz ioctl VIDIOCSYNC %d\n", v));
2709                         return v4l_sync(zr, v);
2710                 }
2711
2712         case VIDIOCMCAPTURE:
2713                 {
2714                         struct video_mmap vm;
2715
2716                         if (copy_from_user((void *) &vm, (void *) arg, sizeof(vm))) {
2717                                 return -EFAULT;
2718                         }
2719                         IOCTL_DEBUG(printk("buz ioctl VIDIOCMCAPTURE frame=%d geom=%dx%d fmt=%d\n",
2720                                vm.frame, vm.height, vm.width, vm.format));
2721                         return v4l_grab(zr, &vm);
2722                 }
2723
2724         case VIDIOCGMBUF:
2725                 {
2726                         struct video_mbuf vm;
2727                         int i;
2728
2729                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGMBUF\n"));
2730
2731                         vm.size = v4l_nbufs * v4l_bufsize;
2732                         vm.frames = v4l_nbufs;
2733                         for (i = 0; i < v4l_nbufs; i++) {
2734                                 vm.offsets[i] = i * v4l_bufsize;
2735                         }
2736
2737                         /* The next mmap will map the V4L buffers */
2738                         zr->map_mjpeg_buffers = 0;
2739
2740                         if (copy_to_user(arg, &vm, sizeof(vm))) {
2741                                 return -EFAULT;
2742                         }
2743                         return 0;
2744                 }
2745
2746         case VIDIOCGUNIT:
2747                 {
2748                         struct video_unit vu;
2749
2750                         IOCTL_DEBUG(printk("buz ioctl VIDIOCGUNIT\n"));
2751                         vu.video = zr->video_dev.minor;
2752                         vu.vbi = VIDEO_NO_UNIT;
2753                         vu.radio = VIDEO_NO_UNIT;
2754                         vu.audio = VIDEO_NO_UNIT;
2755                         vu.teletext = VIDEO_NO_UNIT;
2756                         if (copy_to_user(arg, &vu, sizeof(vu)))
2757                                 return -EFAULT;
2758                         return 0;
2759                 }
2760
2761                 /*
2762                  * RJ: In principal we could support subcaptures for V4L grabbing.
2763                  *     Not even the famous BTTV driver has them, however.
2764                  *     If there should be a strong demand, one could consider
2765                  *     to implement them.
2766                  */
2767         case VIDIOCGCAPTURE:
2768         case VIDIOCSCAPTURE:
2769                         return -EINVAL;
2770
2771         case BUZIOC_G_PARAMS:
2772                 {
2773                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_G_PARAMS\n"));
2774                         if (copy_to_user(arg, &(zr->params), sizeof(zr->params)))
2775                                 return -EFAULT;
2776                         return 0;
2777                 }
2778
2779         case BUZIOC_S_PARAMS:
2780                 {
2781                         struct zoran_params bp;
2782                         int input, on;
2783
2784                         if (zr->codec_mode != BUZ_MODE_IDLE) {
2785                                 return -EINVAL;
2786                         }
2787                         if (copy_from_user(&bp, arg, sizeof(bp))) {
2788                                 return -EFAULT;
2789                         }
2790                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_S_PARAMS\n"));
2791
2792                         /* Check the params first before overwriting our internal values */
2793
2794                         if (zoran_check_params(zr, &bp))
2795                                 return -EINVAL;
2796
2797                         zr->params = bp;
2798
2799                         /* Make changes of input and norm go into effect immediatly */
2800
2801                         /* We switch overlay off and on since a change in the norm
2802                            needs different VFE settings */
2803
2804                         on = zr->v4l_overlay_active && !zr->v4l_memgrab_active;
2805                         if (on)
2806                                 zr36057_overlay(zr, 0);
2807
2808                         input = zr->params.input == 0 ? 3 : 7;
2809                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &input);
2810                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &zr->params.norm);
2811                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEOENCODER, ENCODER_SET_NORM, &zr->params.norm);
2812
2813                         if (on)
2814                                 zr36057_overlay(zr, 1);
2815
2816                         if (copy_to_user(arg, &bp, sizeof(bp))) {
2817                                 return -EFAULT;
2818                         }
2819                         return 0;
2820                 }
2821
2822         case BUZIOC_REQBUFS:
2823                 {
2824                         struct zoran_requestbuffers br;
2825
2826                         if (zr->jpg_buffers_allocated) {
2827                                 return -EINVAL;
2828                         }
2829                         if (copy_from_user(&br, arg, sizeof(br))) {
2830                                 return -EFAULT;
2831                         }
2832                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_REQBUFS count = %lu size=%lu\n",
2833                                            br.count, br.size));
2834                         /* Enforce reasonable lower and upper limits */
2835                         if (br.count < 4)
2836                                 br.count = 4;   /* Could be choosen smaller */
2837                         if (br.count > BUZ_MAX_FRAME)
2838                                 br.count = BUZ_MAX_FRAME;
2839                         br.size = PAGE_ALIGN(br.size);
2840                         if (br.size < 8192)
2841                                 br.size = 8192;         /* Arbitrary */
2842                         /* br.size is limited by 1 page for the stat_com tables to a Maximum of 2 MB */
2843                         if (br.size > (512 * 1024))
2844                                 br.size = (512 * 1024);         /* 512 K should be enough */
2845                         if (zr->need_contiguous && br.size > MAX_KMALLOC_MEM)
2846                                 br.size = MAX_KMALLOC_MEM;
2847
2848                         zr->jpg_nbufs = br.count;
2849                         zr->jpg_bufsize = br.size;
2850
2851                         if (jpg_fbuffer_alloc(zr))
2852                                 return -ENOMEM;
2853
2854                         /* The next mmap will map the MJPEG buffers */
2855                         zr->map_mjpeg_buffers = 1;
2856
2857                         if (copy_to_user(arg, &br, sizeof(br))) {
2858                                 return -EFAULT;
2859                         }
2860                         return 0;
2861                 }
2862
2863         case BUZIOC_QBUF_CAPT:
2864                 {
2865                         int nb;
2866
2867                         if (copy_from_user((void *) &nb, (void *) arg, sizeof(int))) {
2868                                 return -EFAULT;
2869                         }
2870                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_QBUF_CAPT %d\n", nb));
2871                         return jpg_qbuf(zr, nb, BUZ_MODE_MOTION_COMPRESS);
2872                 }
2873
2874         case BUZIOC_QBUF_PLAY:
2875                 {
2876                         int nb;
2877
2878                         if (copy_from_user((void *) &nb, (void *) arg, sizeof(int))) {
2879                                 return -EFAULT;
2880                         }
2881                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_QBUF_PLAY %d\n", nb));
2882                         return jpg_qbuf(zr, nb, BUZ_MODE_MOTION_DECOMPRESS);
2883                 }
2884
2885         case BUZIOC_SYNC:
2886                 {
2887                         struct zoran_sync bs;
2888                         int res;
2889
2890                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_SYNC\n"));
2891                         res = jpg_sync(zr, &bs);
2892                         if (copy_to_user(arg, &bs, sizeof(bs))) {
2893                                 return -EFAULT;
2894                         }
2895                         return res;
2896                 }
2897
2898         case BUZIOC_G_STATUS:
2899                 {
2900                         struct zoran_status bs;
2901                         int norm, input, status;
2902
2903                         if (zr->codec_mode != BUZ_MODE_IDLE) {
2904                                 return -EINVAL;
2905                         }
2906                         if (copy_from_user(&bs, arg, sizeof(bs))) {
2907                                 return -EFAULT;
2908                         }
2909                         IOCTL_DEBUG(printk("buz ioctl BUZIOC_G_STATUS\n"));
2910                         switch (bs.input) {
2911                         case 0:
2912                                 input = 3;
2913                                 break;
2914                         case 1:
2915                                 input = 7;
2916                                 break;
2917                         default:
2918                                 return -EINVAL;
2919                         }
2920
2921                         /* Set video norm to VIDEO_MODE_AUTO */
2922
2923                         norm = VIDEO_MODE_AUTO;
2924                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &input);
2925                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &norm);
2926
2927                         /* sleep 1 second */
2928
2929                         schedule_timeout(HZ);
2930
2931                         /* Get status of video decoder */
2932
2933                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_GET_STATUS, &status);
2934                         bs.signal = (status & DECODER_STATUS_GOOD) ? 1 : 0;
2935                         bs.norm = (status & DECODER_STATUS_NTSC) ? VIDEO_MODE_NTSC : VIDEO_MODE_PAL;
2936                         bs.color = (status & DECODER_STATUS_COLOR) ? 1 : 0;
2937
2938                         /* restore previous input and norm */
2939                         input = zr->params.input == 0 ? 3 : 7;
2940                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &input);
2941                         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &zr->params.norm);
2942
2943                         if (copy_to_user(arg, &bs, sizeof(bs))) {
2944                                 return -EFAULT;
2945                         }
2946                         return 0;
2947                 }
2948
2949         default:
2950                     return -ENOIOCTLCMD;
2951
2952         }
2953         return 0;
2954 }
2955
2956
2957 /*
2958  *   This maps the buffers to user space.
2959  *
2960  *   Depending on the state of zr->map_mjpeg_buffers
2961  *   the V4L or the MJPEG buffers are mapped
2962  *
2963  */
2964
2965 static int zoran_mmap(struct video_device *dev, const char *adr, unsigned long size)
2966 {
2967         struct zoran *zr = (struct zoran *) dev;
2968         unsigned long start = (unsigned long) adr;
2969         unsigned long page, pos, todo, fraglen;
2970         int i, j;
2971
2972         if (zr->map_mjpeg_buffers) {
2973                 /* Map the MJPEG buffers */
2974
2975                 if (!zr->jpg_buffers_allocated) {
2976                         return -ENOMEM;
2977                 }
2978                 if (size > zr->jpg_nbufs * zr->jpg_bufsize) {
2979                         return -EINVAL;
2980                 }
2981
2982                 for (i = 0; i < zr->jpg_nbufs; i++) {
2983                         for (j = 0; j < zr->jpg_bufsize / PAGE_SIZE; j++) {
2984                                 fraglen = (zr->jpg_gbuf[i].frag_tab[2 * j + 1] & ~1) << 1;
2985                                 todo = size;
2986                                 if (todo > fraglen)
2987                                         todo = fraglen;
2988                                 pos = (unsigned long) zr->jpg_gbuf[i].frag_tab[2 * j];
2989                                 page = virt_to_phys(bus_to_virt(pos));  /* should just be pos on i386 */
2990                                 if (remap_page_range(start, page, todo, PAGE_SHARED)) {
2991                                         printk(KERN_ERR "%s: zoran_mmap(V4L): remap_page_range failed\n", zr->name);
2992                                         return -EAGAIN;
2993                                 }
2994                                 size -= todo;
2995                                 start += todo;
2996                                 if (size == 0)
2997                                         break;
2998                                 if (zr->jpg_gbuf[i].frag_tab[2 * j + 1] & 1)
2999                                         break;  /* was last fragment */
3000                         }
3001                         if (size == 0)
3002                                 break;
3003                 }
3004         } else {
3005                 /* Map the V4L buffers */
3006
3007                 if (size > v4l_nbufs * v4l_bufsize) {
3008                         return -EINVAL;
3009                 }
3010
3011                 for (i = 0; i < v4l_nbufs; i++) {
3012                         todo = size;
3013                         if (todo > v4l_bufsize)
3014                                 todo = v4l_bufsize;
3015                         page = zr->v4l_gbuf[i].fbuffer_phys;
3016                         DEBUG(printk("V4L remap page range %d 0x%x %d to 0x%x\n", i, page, todo, start));
3017                         if (remap_page_range(start, page, todo, PAGE_SHARED)) {
3018                                 printk(KERN_ERR "%s: zoran_mmap(V4L): remap_page_range failed\n", zr->name);
3019                                 return -EAGAIN;
3020                         }
3021                         size -= todo;
3022                         start += todo;
3023                         if (size == 0)
3024                                 break;
3025                 }
3026         }
3027         return 0;
3028 }
3029
3030 static struct video_device zoran_template =
3031 {
3032         name:           BUZ_NAME,
3033         type:           VID_TYPE_CAPTURE | VID_TYPE_OVERLAY | VID_TYPE_CLIPPING | VID_TYPE_FRAMERAM |
3034                         VID_TYPE_SCALES | VID_TYPE_SUBCAPTURE,
3035         hardware:       VID_HARDWARE_ZR36067,
3036         open:           zoran_open,
3037         close:          zoran_close,
3038         read:           zoran_read,
3039         write:          zoran_write,
3040         ioctl:          zoran_ioctl,
3041         mmap:           zoran_mmap,
3042 };
3043
3044 static int zr36057_init(int i)
3045 {
3046         struct zoran *zr = &zoran[i];
3047         unsigned long mem;
3048         unsigned mem_needed;
3049         int j;
3050         int rev;
3051
3052         /* reset zr36057 */
3053         btwrite(0, ZR36057_SPGPPCR);
3054         mdelay(10);
3055
3056         /* default setup of all parameters which will persist beetween opens */
3057
3058         zr->user = 0;
3059
3060         init_waitqueue_head(&zr->v4l_capq);
3061         init_waitqueue_head(&zr->jpg_capq);
3062
3063         zr->map_mjpeg_buffers = 0;      /* Map V4L buffers by default */
3064
3065         zr->jpg_nbufs = 0;
3066         zr->jpg_bufsize = 0;
3067         zr->jpg_buffers_allocated = 0;
3068
3069         zr->buffer_set = 0;     /* Flag if frame buffer has been set */
3070         zr->buffer.base = (void *) vidmem;
3071         zr->buffer.width = 0;
3072         zr->buffer.height = 0;
3073         zr->buffer.depth = 0;
3074         zr->buffer.bytesperline = 0;
3075
3076         zr->params.norm = default_norm ? 1 : 0; /* Avoid nonsense settings from user */
3077         zr->params.input = default_input ? 1 : 0;       /* Avoid nonsense settings from user */
3078         zr->video_interlace = 0;
3079
3080         /* Should the following be reset at every open ? */
3081
3082         zr->picture.colour = 32768;
3083         zr->picture.brightness = 32768;
3084         zr->picture.hue = 32768;
3085         zr->picture.contrast = 32768;
3086         zr->picture.whiteness = 0;
3087         zr->picture.depth = 0;
3088         zr->picture.palette = 0;
3089
3090         for (j = 0; j < VIDEO_MAX_FRAME; j++) {
3091                 zr->v4l_gbuf[i].fbuffer = 0;
3092                 zr->v4l_gbuf[i].fbuffer_phys = 0;
3093                 zr->v4l_gbuf[i].fbuffer_bus = 0;
3094         }
3095
3096         zr->stat_com = 0;
3097
3098         /* default setup (will be repeated at every open) */
3099
3100         zoran_open_init_params(zr);
3101
3102         /* allocate memory *before* doing anything to the hardware in case allocation fails */
3103
3104         /* STAT_COM table and overlay mask */
3105
3106         mem_needed = (BUZ_NUM_STAT_COM + ((BUZ_MAX_WIDTH + 31) / 32) * BUZ_MAX_HEIGHT) * 4;
3107         mem = (unsigned long) kmalloc(mem_needed, GFP_KERNEL);
3108         if (!mem) {
3109                 return -ENOMEM;
3110         }
3111         memset((void *) mem, 0, mem_needed);
3112
3113         zr->stat_com = (u32 *) mem;
3114         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
3115                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
3116         }
3117         zr->overlay_mask = (u32 *) (mem + BUZ_NUM_STAT_COM * 4);
3118
3119         /* Initialize zr->jpg_gbuf */
3120
3121         for (j = 0; j < BUZ_MAX_FRAME; j++) {
3122                 zr->jpg_gbuf[j].frag_tab = 0;
3123                 zr->jpg_gbuf[j].frag_tab_bus = 0;
3124                 zr->jpg_gbuf[j].state = BUZ_STATE_USER;
3125                 zr->jpg_gbuf[j].bs.frame = j;
3126         }
3127
3128         /* take zr36057 out of reset now */
3129         btwrite(ZR36057_SPGPPCR_SoftReset, ZR36057_SPGPPCR);
3130         mdelay(10);
3131
3132         /* stop all DMA processes */
3133         btwrite(ZR36057_MCTCR_CFlush, ZR36057_MCTCR);
3134         btand(~ZR36057_VDCR_VidEn, ZR36057_VDCR);
3135         /* assert P_Reset */
3136         btwrite(0, ZR36057_JPC);
3137
3138         switch(zr->board)
3139         {
3140                 case BOARD_BUZ:
3141
3142                         /* set up GPIO direction */
3143                         btwrite(ZR36057_SPGPPCR_SoftReset | 0, ZR36057_SPGPPCR);
3144
3145                         /* Set up guest bus timing - Guests 0..3 Tdur=12, Trec=3 */
3146                         btwrite((GPIO_MASK << 24) | 0x8888, ZR36057_GPPGCR1);
3147                         mdelay(10);
3148
3149                         /* reset video decoder */
3150
3151                         GPIO(zr, 0, 0);
3152                         mdelay(10);
3153                         GPIO(zr, 0, 1);
3154                         mdelay(10);
3155
3156                         /* reset JPEG codec */
3157                         zr36060_sleep(zr, 0);
3158                         mdelay(10);
3159                         zr36060_reset(zr);
3160                         mdelay(10);
3161
3162                         /* display codec revision */
3163                         if ((rev=zr36060_read_8(zr, 0x022)) == 0x33) {
3164                                 printk(KERN_INFO "%s: Zoran ZR36060 (rev %d)\n",
3165                                zr->name, zr36060_read_8(zr, 0x023));
3166                         } else {
3167                                 printk(KERN_ERR "%s: Zoran ZR36060 not found (Rev=%d)\n", zr->name, rev);
3168                                 kfree((void *) zr->stat_com);
3169                                 return -1;
3170                         }
3171                         break;
3172
3173                 case BOARD_LML33:
3174 //                      btwrite(btread(ZR36057_SPGPPCR)&~ZR36057_SPGPPCR_SoftReset , ZR36057_SPGPPCR);
3175 //                      udelay(100);
3176 //                      btwrite(btread(ZR36057_SPGPPCR)|ZR36057_SPGPPCR_SoftReset , ZR36057_SPGPPCR);
3177 //                      udelay(1000);
3178
3179                         /*
3180                          *      Set up the GPIO direction
3181                          */
3182                         btwrite(btread(ZR36057_SPGPPCR_SoftReset)|0 , ZR36057_SPGPPCR);
3183                         /* Set up guest bus timing - Guests 0..2 Tdur=12, Trec=3 */
3184                         btwrite(0xFF00F888, ZR36057_GPPGCR1);
3185                         mdelay(10);
3186                         GPIO(zr, 5, 0);         /* Analog video bypass */
3187                         udelay(3000);
3188                         GPIO(zr, 0, 0);         /* Reset 819 */
3189                         udelay(3000);
3190                         GPIO(zr, 0, 1);         /* 819 back */
3191                         udelay(3000);
3192                         /* reset JPEG codec */
3193                         zr36060_sleep(zr, 0);
3194                         udelay(3000);
3195                         zr36060_reset(zr);
3196                         udelay(3000);
3197
3198                         /* display codec revision */
3199                         if ((rev=zr36060_read_8(zr, 0x022)) == 0x33) {
3200                                 printk(KERN_INFO "%s: Zoran ZR36060 (rev %d)\n",
3201                                zr->name, zr36060_read_8(zr, 0x023));
3202                         } else {
3203                                 printk(KERN_ERR "%s: Zoran ZR36060 not found (rev=%d)\n", zr->name, rev);
3204                                 kfree((void *) zr->stat_com);
3205                                 return -1;
3206                         }
3207                         break;
3208         }
3209         /* i2c */
3210         memcpy(&zr->i2c, &zoran_i2c_bus_template, sizeof(struct i2c_bus));
3211         sprintf(zr->i2c.name, "zoran%u", zr->id);
3212         zr->i2c.data = zr;
3213         if (i2c_register_bus(&zr->i2c) < 0) {
3214                 kfree((void *) zr->stat_com);
3215                 return -1;
3216         }
3217         /*
3218          *   Now add the template and register the device unit.
3219          */
3220         memcpy(&zr->video_dev, &zoran_template, sizeof(zoran_template));
3221         sprintf(zr->video_dev.name, "zoran%u", zr->id);
3222         if (video_register_device(&zr->video_dev, VFL_TYPE_GRABBER) < 0) {
3223                 i2c_unregister_bus(&zr->i2c);
3224                 kfree((void *) zr->stat_com);
3225                 return -1;
3226         }
3227         /* toggle JPEG codec sleep to sync PLL */
3228         zr36060_sleep(zr, 1);
3229         mdelay(10);
3230         zr36060_sleep(zr, 0);
3231         mdelay(10);
3232
3233         /* Enable bus-mastering */
3234         pci_set_master(zr->pci_dev);
3235
3236         j = zr->params.input == 0 ? 3 : 7;
3237         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &j);
3238         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &zr->params.norm);
3239         i2c_control_device(&zr->i2c, I2C_DRIVERID_VIDEOENCODER, ENCODER_SET_NORM, &zr->params.norm);
3240
3241         /* set individual interrupt enables (without GIRQ0)
3242            but don't global enable until zoran_open() */
3243
3244         btwrite(IRQ_MASK & ~ZR36057_ISR_GIRQ0, ZR36057_ICR);
3245
3246         if(request_irq(zr->pci_dev->irq, zoran_irq,
3247                SA_SHIRQ | SA_INTERRUPT, zr->name, (void *) zr)<0)
3248         {
3249                 printk(KERN_ERR "%s: Can't assign irq.\n", zr->name);
3250                 video_unregister_device(&zr->video_dev);
3251                 i2c_unregister_bus(&zr->i2c);
3252                 kfree((void *) zr->stat_com);
3253                 return -1;
3254         }
3255         zr->initialized = 1;
3256         return 0;
3257 }
3258
3259
3260
3261 static void release_zoran(void)
3262 {
3263         u8 command;
3264         int i;
3265         struct zoran *zr;
3266
3267         for (i = 0; i < zoran_num; i++) {
3268                 zr = &zoran[i];
3269
3270                 if (!zr->initialized)
3271                         continue;
3272
3273                 /* unregister i2c_bus */
3274                 i2c_unregister_bus((&zr->i2c));
3275
3276                 /* disable PCI bus-mastering */
3277                 pci_read_config_byte(zr->pci_dev, PCI_COMMAND, &command);
3278                 command &= ~PCI_COMMAND_MASTER;
3279                 pci_write_config_byte(zr->pci_dev, PCI_COMMAND, command);
3280
3281                 /* put chip into reset */
3282                 btwrite(0, ZR36057_SPGPPCR);
3283
3284                 free_irq(zr->pci_dev->irq, zr);
3285
3286                 /* unmap and free memory */
3287
3288                 kfree((void *) zr->stat_com);
3289
3290                 iounmap(zr->zr36057_mem);
3291
3292                 video_unregister_device(&zr->video_dev);
3293         }
3294 }
3295
3296 /*
3297  *   Scan for a Buz card (actually for the PCI controller ZR36057),
3298  *   request the irq and map the io memory
3299  */
3300
3301 static int find_zr36057(void)
3302 {
3303         unsigned char latency;
3304         struct zoran *zr;
3305         struct pci_dev *dev = NULL;
3306
3307         zoran_num = 0;
3308
3309         while (zoran_num < BUZ_MAX
3310                && (dev = pci_find_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
3311                 zr = &zoran[zoran_num];
3312                 zr->pci_dev = dev;
3313                 zr->zr36057_mem = NULL;
3314                 zr->id = zoran_num;
3315                 sprintf(zr->name, "zoran%u", zr->id);
3316
3317                 spin_lock_init(&zr->lock);
3318
3319                 if (pci_enable_device(dev))
3320                         continue;
3321
3322                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
3323                 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION, &zr->revision);
3324                 if (zr->revision < 2) {
3325                         printk(KERN_INFO "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
3326                                zr->name, zr->revision, zr->pci_dev->irq, zr->zr36057_adr);
3327                 } else {
3328                         unsigned short ss_vendor_id, ss_id;
3329
3330                         ss_vendor_id = zr->pci_dev->subsystem_vendor;
3331                         ss_id = zr->pci_dev->subsystem_device;
3332                         printk(KERN_INFO "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
3333                                zr->name, zr->revision, zr->pci_dev->irq, zr->zr36057_adr);
3334                         printk(KERN_INFO "%s: subsystem vendor=0x%04x id=0x%04x\n",
3335                                zr->name, ss_vendor_id, ss_id);
3336                         if(ss_vendor_id==0xFF10 && ss_id == 0xDE41)
3337                         {
3338                                 zr->board = BOARD_LML33;
3339                                 printk(KERN_INFO "%s: LML33 detected.\n", zr->name);
3340                         }
3341                 }
3342
3343                 zr->zr36057_mem = ioremap(zr->zr36057_adr, 0x1000);
3344                 if (!zr->zr36057_mem) {
3345                         printk(KERN_ERR "%s: ioremap failed\n", zr->name);
3346                         /* XXX handle error */
3347                 }
3348
3349                 /* set PCI latency timer */
3350                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, &latency);
3351                 if (latency != 48) {
3352                         printk(KERN_INFO "%s: Changing PCI latency from %d to 48.\n", zr->name, latency);
3353                         latency = 48;
3354                         pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, latency);
3355                 }
3356                 zoran_num++;
3357         }
3358         if (zoran_num == 0)
3359                 printk(KERN_INFO "zoran: no cards found.\n");
3360
3361         return zoran_num;
3362 }
3363
3364 static void handle_chipset(void)
3365 {
3366         if(pci_pci_problems&PCIPCI_FAIL)
3367         {
3368                 printk(KERN_WARNING "buz: This configuration is known to have PCI to PCI DMA problems\n");
3369                 printk(KERN_WARNING "buz: You may not be able to use overlay mode.\n");
3370         }
3371
3372
3373         if(pci_pci_problems&PCIPCI_TRITON)
3374         {
3375                 printk("buz: Enabling Triton support.\n");
3376                 triton = 1;
3377         }
3378
3379         if(pci_pci_problems&PCIPCI_NATOMA)
3380         {
3381                 printk("buz: Enabling Natoma workaround.\n");
3382                 natoma = 1;
3383         }
3384 }
3385
3386 #ifdef MODULE
3387 int init_module(void)
3388 #else
3389 int init_zoran_cards(struct video_init *unused)
3390 #endif
3391 {
3392         int i;
3393
3394
3395         printk(KERN_INFO "Zoran driver 1.00 (c) 1999 Rainer Johanni, Dave Perks.\n");
3396
3397         /* Look for Buz cards */
3398
3399         if (find_zr36057() <= 0) {
3400                 return -EIO;
3401         }
3402         printk(KERN_INFO"zoran: %d zoran card(s) found\n", zoran_num);
3403
3404         if (zoran_num == 0)
3405                 return -ENXIO;
3406
3407
3408         /* check the parameters we have been given, adjust if necessary */
3409
3410         if (v4l_nbufs < 0)
3411                 v4l_nbufs = 0;
3412         if (v4l_nbufs > VIDEO_MAX_FRAME)
3413                 v4l_nbufs = VIDEO_MAX_FRAME;
3414         /* The user specfies the in KB, we want them in byte (and page aligned) */
3415         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
3416         if (v4l_bufsize < 32768)
3417                 v4l_bufsize = 32768;
3418         /* 2 MB is arbitrary but sufficient for the maximum possible images */
3419         if (v4l_bufsize > 2048 * 1024)
3420                 v4l_bufsize = 2048 * 1024;
3421
3422         printk(KERN_INFO "zoran: using %d V4L buffers of size %d KB\n", v4l_nbufs, v4l_bufsize >> 10);
3423
3424         /* Use parameter for vidmem or try to find a video card */
3425
3426         if (vidmem) {
3427                 printk(KERN_INFO "zoran: Using supplied video memory base address @ 0x%lx\n", vidmem);
3428         }
3429
3430         /* check if we have a Triton or Natome chipset */
3431
3432         handle_chipset();
3433
3434         /* take care of Natoma chipset and a revision 1 zr36057 */
3435
3436         for (i = 0; i < zoran_num; i++) {
3437                 if (natoma && zoran[i].revision <= 1) {
3438                         zoran[i].need_contiguous = 1;
3439                         printk(KERN_INFO "%s: ZR36057/Natome bug, max. buffer size is 128K\n", zoran[i].name);
3440                 } else {
3441                         zoran[i].need_contiguous = 0;
3442                 }
3443         }
3444
3445         /* initialize the Buzs */
3446
3447         /* We have to know which ones must be released if an error occurs */
3448         for (i = 0; i < zoran_num; i++)
3449                 zoran[i].initialized = 0;
3450
3451         for (i = 0; i < zoran_num; i++) {
3452                 if (zr36057_init(i) < 0) {
3453                         release_zoran();
3454                         return -EIO;
3455                 }
3456         }
3457
3458         return 0;
3459 }
3460
3461
3462
3463 #ifdef MODULE
3464
3465 void cleanup_module(void)
3466 {
3467         release_zoran();
3468 }
3469
3470 #endif