git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/zr36120.c

   1 /*
   2     zr36120.c - Zoran 36120/36125 based framegrabbers
   3
   4     Copyright (C) 1998-1999 Pauline Middelink <middelin@polyware.nl>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include <linux/module.h>
  22 #include <linux/delay.h>
  23 #include <linux/init.h>
  24 #include <linux/errno.h>
  25 #include <linux/fs.h>
  26 #include <linux/kernel.h>
  27 #include <linux/major.h>
  28 #include <linux/slab.h>
  29 #include <linux/vmalloc.h>
  30 #include <linux/mm.h>
  31 #include <linux/pci.h>
  32 #include <linux/signal.h>
  33 #include <linux/wait.h>
  34 #include <asm/io.h>
  35 #include <asm/pgtable.h>
  36 #include <asm/page.h>
  37 #include <linux/sched.h>
  38 #include <linux/video_decoder.h>
  39
  40 #include <asm/uaccess.h>
  41
  42 #include "tuner.h"
  43 #include "zr36120.h"
  44 #include "zr36120_mem.h"
  45
  46 /* mark an required function argument unused - lintism */
  47 #define UNUSED(x)       (void)(x)
  48
  49 /* sensible default */
  50 #ifndef CARDTYPE
  51 #define CARDTYPE 0
  52 #endif
  53
  54 /* Anybody who uses more than four? */
  55 #define ZORAN_MAX 4
  56
  57 static unsigned int triton1=0;                  /* triton1 chipset? */
  58 static unsigned int cardtype[ZORAN_MAX]={ [ 0 ... ZORAN_MAX-1 ] = CARDTYPE };
  59 static int video_nr = -1;
  60 static int vbi_nr = -1;
  61
  62 static struct pci_device_id zr36120_pci_tbl[] = {
  63         { PCI_VENDOR_ID_ZORAN,PCI_DEVICE_ID_ZORAN_36120,
  64           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  65         { 0 }
  66 };
  67 MODULE_DEVICE_TABLE(pci, zr36120_pci_tbl);
  68
  69 MODULE_AUTHOR("Pauline Middelink <middelin@polyware.nl>");
  70 MODULE_DESCRIPTION("Zoran ZR36120 based framegrabber");
  71 MODULE_LICENSE("GPL");
  72
  73 MODULE_PARM(triton1,"i");
  74 MODULE_PARM(cardtype,"1-" __MODULE_STRING(ZORAN_MAX) "i");
  75 MODULE_PARM(video_nr,"i");
  76 MODULE_PARM(vbi_nr,"i");
  77
  78 static int zoran_cards;
  79 static struct zoran zorans[ZORAN_MAX];
  80
  81 /*
  82  * the meaning of each element can be found in zr36120.h
  83  * Determining the value of gpdir/gpval can be tricky. The
  84  * best way is to run the card under the original software
  85  * and read the values from the general purpose registers
  86  * 0x28 and 0x2C. How you do that is left as an exercise
  87  * to the impatient reader :)
  88  */
  89 #define T 1     /* to separate the bools from the ints */
  90 #define F 0
  91 static struct tvcard tvcards[] = {
  92         /* reported working by <middelin@polyware.nl> */
  93 /*0*/   { "Trust Victor II",
  94           2, 0, T, T, T, T, 0x7F, 0x80, { 1, SVHS(6) }, { 0 } },
  95         /* reported working by <Michael.Paxton@aihw.gov.au>  */
  96 /*1*/   { "Aitech WaveWatcher TV-PCI",
  97           3, 0, T, F, T, T, 0x7F, 0x80, { 1, TUNER(3), SVHS(6) }, { 0 } },
  98         /* reported working by ? */
  99 /*2*/   { "Genius Video Wonder PCI Video Capture Card",
 100           2, 0, T, T, T, T, 0x7F, 0x80, { 1, SVHS(6) }, { 0 } },
 101         /* reported working by <Pascal.Gabriel@wanadoo.fr> */
 102 /*3*/   { "Guillemot Maxi-TV PCI",
 103           2, 0, T, T, T, T, 0x7F, 0x80, { 1, SVHS(6) }, { 0 } },
 104         /* reported working by "Craig Whitmore <lennon@igrin.co.nz> */
 105 /*4*/   { "Quadrant Buster",
 106           3, 3, T, F, T, T, 0x7F, 0x80, { SVHS(1), TUNER(2), 3 }, { 1, 2, 3 } },
 107         /* a debug entry which has all inputs mapped */
 108 /*5*/   { "ZR36120 based framegrabber (all inputs enabled)",
 109           6, 0, T, T, T, T, 0x7F, 0x80, { 1, 2, 3, 4, 5, 6 }, { 0 } }
 110 };
 111 #undef T
 112 #undef F
 113 #define NRTVCARDS (sizeof(tvcards)/sizeof(tvcards[0]))
 114
 115 #ifdef __sparc__
 116 #define ENDIANESS       0
 117 #else
 118 #define ENDIANESS       ZORAN_VFEC_LE
 119 #endif
 120
 121 static struct { const char name[8]; uint mode; uint bpp; } palette2fmt[] = {
 122 /* n/a     */   { "n/a",     0, 0 },
 123 /* GREY    */   { "GRAY",    0, 0 },
 124 /* HI240   */   { "HI240",   0, 0 },
 125 /* RGB565  */   { "RGB565",  ZORAN_VFEC_RGB_RGB565|ENDIANESS, 2 },
 126 /* RGB24   */   { "RGB24",   ZORAN_VFEC_RGB_RGB888|ENDIANESS|ZORAN_VFEC_PACK24, 3 },
 127 /* RGB32   */   { "RGB32",   ZORAN_VFEC_RGB_RGB888|ENDIANESS, 4 },
 128 /* RGB555  */   { "RGB555",  ZORAN_VFEC_RGB_RGB555|ENDIANESS, 2 },
 129 /* YUV422  */   { "YUV422",  ZORAN_VFEC_RGB_YUV422|ENDIANESS, 2 },
 130 /* YUYV    */   { "YUYV",    0, 0 },
 131 /* UYVY    */   { "UYVY",    0, 0 },
 132 /* YUV420  */   { "YUV420",  0, 0 },
 133 /* YUV411  */   { "YUV411",  0, 0 },
 134 /* RAW     */   { "RAW",     0, 0 },
 135 /* YUV422P */   { "YUV422P", 0, 0 },
 136 /* YUV411P */   { "YUV411P", 0, 0 }};
 137 #define NRPALETTES (sizeof(palette2fmt)/sizeof(palette2fmt[0]))
 138 #undef ENDIANESS
 139
 140 /* ----------------------------------------------------------------------- */
 141 /* ZORAN chipset detector                                                 */
 142 /* shamelessly stolen from bttv.c                                         */
 143 /* Reason for beeing here: we need to detect if we are running on a        */
 144 /* Triton based chipset, and if so, enable a certain bit                   */
 145 /* ----------------------------------------------------------------------- */
 146 static
 147 void __init handle_chipset(void)
 148 {
 149         /* Just in case some nut set this to something dangerous */
 150         if (triton1)
 151                 triton1 = ZORAN_VDC_TRICOM;
 152
 153         if (pci_pci_problems & PCIPCI_TRITON) {
 154                 printk(KERN_INFO "zoran: Host bridge 82437FX Triton PIIX\n");
 155                 triton1 = ZORAN_VDC_TRICOM;
 156         }
 157 }
 158
 159 /* ----------------------------------------------------------------------- */
 160 /* ZORAN functions                                                         */
 161 /* ----------------------------------------------------------------------- */
 162
 163 static void zoran_set_geo(struct zoran* ztv, struct vidinfo* i);
 164
 165 #if 0 /* unused */
 166 static
 167 void zoran_dump(struct zoran *ztv)
 168 {
 169         char    str[256];
 170         char    *p=str; /* shut up, gcc! */
 171         int     i;
 172
 173         for (i=0; i<0x60; i+=4) {
 174                 if ((i % 16) == 0) {
 175                         if (i) printk("%s\n",str);
 176                         p = str;
 177                         p+= sprintf(str, KERN_DEBUG "       %04x: ",i);
 178                 }
 179                 p += sprintf(p, "%08x ",zrread(i));
 180         }
 181 }
 182 #endif /* unused */
 183
 184 static
 185 void reap_states(struct zoran* ztv)
 186 {
 187         /* count frames */
 188         ztv->fieldnr++;
 189
 190         /*
 191          * Are we busy at all?
 192          * This depends on if there is a workqueue AND the
 193          * videotransfer is enabled on the chip...
 194          */
 195         if (ztv->workqueue && (zrread(ZORAN_VDC) & ZORAN_VDC_VIDEN))
 196         {
 197                 struct vidinfo* newitem;
 198
 199                 /* did we get a complete frame? */
 200                 if (zrread(ZORAN_VSTR) & ZORAN_VSTR_GRAB)
 201                         return;
 202
 203 DEBUG(printk(CARD_DEBUG "completed %s at %p\n",CARD,ztv->workqueue->kindof==FBUFFER_GRAB?"grab":"read",ztv->workqueue));
 204
 205                 /* we are done with this buffer, tell everyone */
 206                 ztv->workqueue->status = FBUFFER_DONE;
 207                 ztv->workqueue->fieldnr = ztv->fieldnr;
 208                 /* not good, here for BTTV_FIELDNR reasons */
 209                 ztv->lastfieldnr = ztv->fieldnr;
 210
 211                 switch (ztv->workqueue->kindof) {
 212                  case FBUFFER_GRAB:
 213                         wake_up_interruptible(&ztv->grabq);
 214                         break;
 215                  case FBUFFER_VBI:
 216                         wake_up_interruptible(&ztv->vbiq);
 217                         break;
 218                  default:
 219                         printk(CARD_INFO "somebody killed the workqueue (kindof=%d)!\n",CARD,ztv->workqueue->kindof);
 220                 }
 221
 222                 /* item completed, skip to next item in queue */
 223                 write_lock(&ztv->lock);
 224                 newitem = ztv->workqueue->next;
 225                 ztv->workqueue->next = 0;       /* mark completed */
 226                 ztv->workqueue = newitem;
 227                 write_unlock(&ztv->lock);
 228         }
 229
 230         /*
 231          * ok, so it seems we have nothing in progress right now.
 232          * Lets see if we can find some work.
 233          */
 234         if (ztv->workqueue)
 235         {
 236                 struct vidinfo* newitem;
 237 again:
 238
 239 DEBUG(printk(CARD_DEBUG "starting %s at %p\n",CARD,ztv->workqueue->kindof==FBUFFER_GRAB?"grab":"read",ztv->workqueue));
 240
 241                 /* loadup the frame settings */
 242                 read_lock(&ztv->lock);
 243                 zoran_set_geo(ztv,ztv->workqueue);
 244                 read_unlock(&ztv->lock);
 245
 246                 switch (ztv->workqueue->kindof) {
 247                  case FBUFFER_GRAB:
 248                  case FBUFFER_VBI:
 249                         zrand(~ZORAN_OCR_OVLEN, ZORAN_OCR);
 250                         zror(ZORAN_VSTR_SNAPSHOT,ZORAN_VSTR);
 251                         zror(ZORAN_VDC_VIDEN,ZORAN_VDC);
 252
 253                         /* start single-shot grab */
 254                         zror(ZORAN_VSTR_GRAB, ZORAN_VSTR);
 255                         break;
 256                  default:
 257                         printk(CARD_INFO "what is this doing on the queue? (kindof=%d)\n",CARD,ztv->workqueue->kindof);
 258                         write_lock(&ztv->lock);
 259                         newitem = ztv->workqueue->next;
 260                         ztv->workqueue->next = 0;
 261                         ztv->workqueue = newitem;
 262                         write_unlock(&ztv->lock);
 263                         if (newitem)
 264                                 goto again;     /* yeah, sure.. */
 265                 }
 266                 /* bye for now */
 267                 return;
 268         }
 269 DEBUG(printk(CARD_DEBUG "nothing in queue\n",CARD));
 270
 271         /*
 272          * What? Even the workqueue is empty? Am i really here
 273          * for nothing? Did i come all that way to... do nothing?
 274          */
 275
 276         /* do we need to overlay? */
 277         if (test_bit(STATE_OVERLAY, &ztv->state))
 278         {
 279                 /* are we already overlaying? */
 280                 if (!(zrread(ZORAN_OCR) & ZORAN_OCR_OVLEN) ||
 281                     !(zrread(ZORAN_VDC) & ZORAN_VDC_VIDEN))
 282                 {
 283 DEBUG(printk(CARD_DEBUG "starting overlay\n",CARD));
 284
 285                         read_lock(&ztv->lock);
 286                         zoran_set_geo(ztv,&ztv->overinfo);
 287                         read_unlock(&ztv->lock);
 288
 289                         zror(ZORAN_OCR_OVLEN, ZORAN_OCR);
 290                         zrand(~ZORAN_VSTR_SNAPSHOT,ZORAN_VSTR);
 291                         zror(ZORAN_VDC_VIDEN,ZORAN_VDC);
 292                 }
 293
 294                 /*
 295                  * leave overlaying on, but turn interrupts off.
 296                  */
 297                 zrand(~ZORAN_ICR_EN,ZORAN_ICR);
 298                 return;
 299         }
 300
 301         /* do we have any VBI idle time processing? */
 302         if (test_bit(STATE_VBI, &ztv->state))
 303         {
 304                 struct vidinfo* item;
 305                 struct vidinfo* lastitem;
 306
 307                 /* protect the workqueue */
 308                 write_lock(&ztv->lock);
 309                 lastitem = ztv->workqueue;
 310                 if (lastitem)
 311                         while (lastitem->next) lastitem = lastitem->next;
 312                 for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
 313                         if (item->next == 0 && item->status == FBUFFER_FREE)
 314                         {
 315 DEBUG(printk(CARD_DEBUG "%p added to queue\n",CARD,item));
 316                                 item->status = FBUFFER_BUSY;
 317                                 if (!lastitem)
 318                                         ztv->workqueue = item;
 319                                 else
 320                                         lastitem->next = item;
 321                                 lastitem = item;
 322                         }
 323                 write_unlock(&ztv->lock);
 324                 if (ztv->workqueue)
 325                         goto again;     /* hey, _i_ graduated :) */
 326         }
 327
 328         /*
 329          * Then we must be realy IDLE
 330          */
 331 DEBUG(printk(CARD_DEBUG "turning off\n",CARD));
 332         /* nothing further to do, disable DMA and further IRQs */
 333         zrand(~ZORAN_VDC_VIDEN,ZORAN_VDC);
 334         zrand(~ZORAN_ICR_EN,ZORAN_ICR);
 335 }
 336
 337 static
 338 void zoran_irq(int irq, void *dev_id, struct pt_regs * regs)
 339 {
 340         u32 stat,estat;
 341         int count = 0;
 342         struct zoran *ztv = dev_id;
 343
 344         UNUSED(irq); UNUSED(regs);
 345         for (;;) {
 346                 /* get/clear interrupt status bits */
 347                 stat=zrread(ZORAN_ISR);
 348                 estat=stat & zrread(ZORAN_ICR);
 349                 if (!estat)
 350                         return;
 351                 zrwrite(estat,ZORAN_ISR);
 352                 IDEBUG(printk(CARD_DEBUG "estat %08x\n",CARD,estat));
 353                 IDEBUG(printk(CARD_DEBUG " stat %08x\n",CARD,stat));
 354
 355                 if (estat & ZORAN_ISR_CODE)
 356                 {
 357                         IDEBUG(printk(CARD_DEBUG "CodReplIRQ\n",CARD));
 358                 }
 359                 if (estat & ZORAN_ISR_GIRQ0)
 360                 {
 361                         IDEBUG(printk(CARD_DEBUG "GIRQ0\n",CARD));
 362                         if (!ztv->card->usegirq1)
 363                                 reap_states(ztv);
 364                 }
 365                 if (estat & ZORAN_ISR_GIRQ1)
 366                 {
 367                         IDEBUG(printk(CARD_DEBUG "GIRQ1\n",CARD));
 368                         if (ztv->card->usegirq1)
 369                                 reap_states(ztv);
 370                 }
 371
 372                 count++;
 373                 if (count > 10)
 374                         printk(CARD_ERR "irq loop %d (%x)\n",CARD,count,estat);
 375                 if (count > 20)
 376                 {
 377                         zrwrite(0, ZORAN_ICR);
 378                         printk(CARD_ERR "IRQ lockup, cleared int mask\n",CARD);
 379                 }
 380         }
 381 }
 382
 383 static
 384 int zoran_muxsel(struct zoran* ztv, int channel, int norm)
 385 {
 386         int     rv;
 387
 388         /* set the new video norm */
 389         rv = i2c_control_device(&(ztv->i2c), I2C_DRIVERID_VIDEODECODER, DECODER_SET_NORM, &norm);
 390         if (rv)
 391                 return rv;
 392         ztv->norm = norm;
 393
 394         /* map the given channel to the cards decoder's channel */
 395         channel = ztv->card->video_mux[channel] & CHANNEL_MASK;
 396
 397         /* set the new channel */
 398         rv = i2c_control_device(&(ztv->i2c), I2C_DRIVERID_VIDEODECODER, DECODER_SET_INPUT, &channel);
 399         return rv;
 400 }
 401
 402 /* Tell the interrupt handler what to to.  */
 403 static
 404 void zoran_cap(struct zoran* ztv, int on)
 405 {
 406 DEBUG(printk(CARD_DEBUG "zoran_cap(%d) state=%x\n",CARD,on,ztv->state));
 407
 408         if (on) {
 409                 ztv->running = 1;
 410
 411                 /*
 412                  * turn interrupts (back) on. The DMA will be enabled
 413                  * inside the irq handler when it detects a restart.
 414                  */
 415                 zror(ZORAN_ICR_EN,ZORAN_ICR);
 416         }
 417         else {
 418                 /*
 419                  * turn both interrupts and DMA off
 420                  */
 421                 zrand(~ZORAN_VDC_VIDEN,ZORAN_VDC);
 422                 zrand(~ZORAN_ICR_EN,ZORAN_ICR);
 423
 424                 ztv->running = 0;
 425         }
 426 }
 427
 428 static ulong dmask[] = {
 429         0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFC, 0xFFFFFFF8,
 430         0xFFFFFFF0, 0xFFFFFFE0, 0xFFFFFFC0, 0xFFFFFF80,
 431         0xFFFFFF00, 0xFFFFFE00, 0xFFFFFC00, 0xFFFFF800,
 432         0xFFFFF000, 0xFFFFE000, 0xFFFFC000, 0xFFFF8000,
 433         0xFFFF0000, 0xFFFE0000, 0xFFFC0000, 0xFFF80000,
 434         0xFFF00000, 0xFFE00000, 0xFFC00000, 0xFF800000,
 435         0xFF000000, 0xFE000000, 0xFC000000, 0xF8000000,
 436         0xF0000000, 0xE0000000, 0xC0000000, 0x80000000
 437 };
 438
 439 static
 440 void zoran_built_overlay(struct zoran* ztv, int count, struct video_clip *vcp)
 441 {
 442         ulong*  mtop;
 443         int     ystep = (ztv->vidXshift + ztv->vidWidth+31)/32; /* next DWORD */
 444         int     i;
 445
 446 DEBUG(printk(KERN_DEBUG "       overlay at %p, ystep=%d, clips=%d\n",ztv->overinfo.overlay,ystep,count));
 447
 448         for (i=0; i<count; i++) {
 449                 struct video_clip *vp = vcp+i;
 450                 UNUSED(vp);
 451 DEBUG(printk(KERN_DEBUG "       %d: clip(%d,%d,%d,%d)\n", i,vp->x,vp->y,vp->width,vp->height));
 452         }
 453
 454         /*
 455          * activate the visible portion of the screen
 456          * Note we take some shortcuts here, because we
 457          * know the width can never be < 32. (I.e. a DWORD)
 458          * We also assume the overlay starts somewhere in
 459          * the FIRST dword.
 460          */
 461         {
 462                 int start = ztv->vidXshift;
 463                 ulong firstd = dmask[start];
 464                 ulong lastd = ~dmask[(start + ztv->overinfo.w) & 31];
 465                 mtop = ztv->overinfo.overlay;
 466                 for (i=0; i<ztv->overinfo.h; i++) {
 467                         int w = ztv->vidWidth;
 468                         ulong* line = mtop;
 469                         if (start & 31) {
 470                                 *line++ = firstd;
 471                                 w -= 32-(start&31);
 472                         }
 473                         memset(line, ~0, w/8);
 474                         if (w & 31)
 475                                 line[w/32] = lastd;
 476                         mtop += ystep;
 477                 }
 478         }
 479
 480         /* process clipping regions */
 481         for (i=0; i<count; i++) {
 482                 int h;
 483                 if (vcp->x < 0 || (uint)vcp->x > ztv->overinfo.w ||
 484                     vcp->y < 0 || vcp->y > ztv->overinfo.h ||
 485                     vcp->width < 0 || (uint)(vcp->x+vcp->width) > ztv->overinfo.w ||
 486                     vcp->height < 0 || (vcp->y+vcp->height) > ztv->overinfo.h)
 487                 {
 488                         DEBUG(printk(CARD_DEBUG "invalid clipzone (%d,%d,%d,%d) not in (0,0,%d,%d), adapting\n",CARD,vcp->x,vcp->y,vcp->width,vcp->height,ztv->overinfo.w,ztv->overinfo.h));
 489                         if (vcp->x < 0) vcp->x = 0;
 490                         if ((uint)vcp->x > ztv->overinfo.w) vcp->x = ztv->overinfo.w;
 491                         if (vcp->y < 0) vcp->y = 0;
 492                         if (vcp->y > ztv->overinfo.h) vcp->y = ztv->overinfo.h;
 493                         if (vcp->width < 0) vcp->width = 0;
 494                         if ((uint)(vcp->x+vcp->width) > ztv->overinfo.w) vcp->width = ztv->overinfo.w - vcp->x;
 495                         if (vcp->height < 0) vcp->height = 0;
 496                         if (vcp->y+vcp->height > ztv->overinfo.h) vcp->height = ztv->overinfo.h - vcp->y;
 497 //                      continue;
 498                 }
 499
 500                 mtop = &ztv->overinfo.overlay[vcp->y*ystep];
 501                 for (h=0; h<=vcp->height; h++) {
 502                         int w;
 503                         int x = ztv->vidXshift + vcp->x;
 504                         for (w=0; w<=vcp->width; w++) {
 505                                 clear_bit(x&31, &mtop[x/32]);
 506                                 x++;
 507                         }
 508                         mtop += ystep;
 509                 }
 510                 ++vcp;
 511         }
 512
 513         mtop = ztv->overinfo.overlay;
 514         zrwrite(virt_to_bus(mtop), ZORAN_MTOP);
 515         zrwrite(virt_to_bus(mtop+ystep), ZORAN_MBOT);
 516         zraor((ztv->vidInterlace*ystep)<<0,~ZORAN_OCR_MASKSTRIDE,ZORAN_OCR);
 517 }
 518
 519 struct tvnorm
 520 {
 521         u16 Wt, Wa, Ht, Ha, HStart, VStart;
 522 };
 523
 524 static struct tvnorm tvnorms[] = {
 525         /* PAL-BDGHI */
 526 /*      { 864, 720, 625, 576, 131, 21 },*/
 527 /*00*/  { 864, 768, 625, 576, 81, 17 },
 528         /* NTSC */
 529 /*01*/  { 858, 720, 525, 480, 121, 10 },
 530         /* SECAM */
 531 /*02*/  { 864, 720, 625, 576, 131, 21 },
 532         /* BW50 */
 533 /*03*/  { 864, 720, 625, 576, 131, 21 },
 534         /* BW60 */
 535 /*04*/  { 858, 720, 525, 480, 121, 10 }
 536 };
 537 #define TVNORMS (sizeof(tvnorms)/sizeof(tvnorm))
 538
 539 /*
 540  * Program the chip for a setup as described in the vidinfo struct.
 541  *
 542  * Side-effects: calculates vidXshift, vidInterlace,
 543  * vidHeight, vidWidth which are used in a later stage
 544  * to calculate the overlay mask
 545  *
 546  * This is an internal function, as such it does not check the
 547  * validity of the struct members... Spectaculair crashes will
 548  * follow /very/ quick when you're wrong and the chip right :)
 549  */
 550 static
 551 void zoran_set_geo(struct zoran* ztv, struct vidinfo* i)
 552 {
 553         ulong   top, bot;
 554         int     stride;
 555         int     winWidth, winHeight;
 556         int     maxWidth, maxHeight, maxXOffset, maxYOffset;
 557         long    vfec;
 558
 559 DEBUG(printk(CARD_DEBUG "set_geo(rect=(%d,%d,%d,%d), norm=%d, format=%d, bpp=%d, bpl=%d, busadr=%lx, overlay=%p)\n",CARD,i->x,i->y,i->w,i->h,ztv->norm,i->format,i->bpp,i->bpl,i->busadr,i->overlay));
 560
 561         /*
 562          * make sure the DMA transfers are inhibited during our
 563          * reprogramming of the chip
 564          */
 565         zrand(~ZORAN_VDC_VIDEN,ZORAN_VDC);
 566
 567         maxWidth = tvnorms[ztv->norm].Wa;
 568         maxHeight = tvnorms[ztv->norm].Ha/2;
 569         maxXOffset = tvnorms[ztv->norm].HStart;
 570         maxYOffset = tvnorms[ztv->norm].VStart;
 571
 572         /* setup vfec register (keep ExtFl,TopField and VCLKPol settings) */
 573         vfec = (zrread(ZORAN_VFEC) & (ZORAN_VFEC_EXTFL|ZORAN_VFEC_TOPFIELD|ZORAN_VFEC_VCLKPOL)) |
 574                (palette2fmt[i->format].mode & (ZORAN_VFEC_RGB|ZORAN_VFEC_ERRDIF|ZORAN_VFEC_LE|ZORAN_VFEC_PACK24));
 575
 576         /*
 577          * Set top, bottom ptrs. Since these must be DWORD aligned,
 578          * possible adjust the x and the width of the window.
 579          * so the endposition stay the same. The vidXshift will make
 580          * sure we are not writing pixels before the requested x.
 581          */
 582         ztv->vidXshift = 0;
 583         winWidth = i->w;
 584         if (winWidth < 0)
 585                 winWidth = -winWidth;
 586         top = i->busadr + i->x*i->bpp + i->y*i->bpl;
 587         if (top & 3) {
 588                 ztv->vidXshift = (top & 3) / i->bpp;
 589                 winWidth += ztv->vidXshift;
 590                 DEBUG(printk(KERN_DEBUG "       window-x shifted %d pixels left\n",ztv->vidXshift));
 591                 top &= ~3;
 592         }
 593
 594         /*
 595          * bottom points to next frame but in interleaved mode we want
 596          * to 'mix' the 2 frames to one capture, so 'bot' points to one
 597          * (physical) line below the top line.
 598          */
 599         bot = top + i->bpl;
 600         zrwrite(top,ZORAN_VTOP);
 601         zrwrite(bot,ZORAN_VBOT);
 602
 603         /*
 604          * Make sure the winWidth is DWORD aligned too,
 605          * thereby automaticly making sure the stride to the
 606          * next line is DWORD aligned too (as required by spec).
 607          */
 608         if ((winWidth*i->bpp) & 3) {
 609 DEBUG(printk(KERN_DEBUG "       window-width enlarged by %d pixels\n",(winWidth*i->bpp) & 3));
 610                 winWidth += (winWidth*i->bpp) & 3;
 611         }
 612
 613         /* determine the DispMode and stride */
 614         if (i->h >= 0 && i->h <= maxHeight) {
 615                 /* single frame grab suffices for this height. */
 616                 vfec |= ZORAN_VFEC_DISPMOD;
 617                 ztv->vidInterlace = 0;
 618                 stride = i->bpl - (winWidth*i->bpp);
 619                 winHeight = i->h;
 620         }
 621         else {
 622                 /* interleaving needed for this height */
 623                 ztv->vidInterlace = 1;
 624                 stride = i->bpl*2 - (winWidth*i->bpp);
 625                 winHeight = i->h/2;
 626         }
 627         if (winHeight < 0)      /* can happen for VBI! */
 628                 winHeight = -winHeight;
 629
 630         /* safety net, sometimes bpl is too short??? */
 631         if (stride<0) {
 632 DEBUG(printk(CARD_DEBUG "WARNING stride = %d\n",CARD,stride));
 633                 stride = 0;
 634         }
 635
 636         zraor((winHeight<<12)|(winWidth<<0),~(ZORAN_VDC_VIDWINHT|ZORAN_VDC_VIDWINWID), ZORAN_VDC);
 637         zraor(stride<<16,~ZORAN_VSTR_DISPSTRIDE,ZORAN_VSTR);
 638
 639         /* remember vidWidth, vidHeight for overlay calculations */
 640         ztv->vidWidth = winWidth;
 641         ztv->vidHeight = winHeight;
 642 DEBUG(printk(KERN_DEBUG "       top=%08lx, bottom=%08lx\n",top,bot));
 643 DEBUG(printk(KERN_DEBUG "       winWidth=%d, winHeight=%d\n",winWidth,winHeight));
 644 DEBUG(printk(KERN_DEBUG "       maxWidth=%d, maxHeight=%d\n",maxWidth,maxHeight));
 645 DEBUG(printk(KERN_DEBUG "       stride=%d\n",stride));
 646
 647         /*
 648          * determine horizontal scales and crops
 649          */
 650         if (i->w < 0) {
 651                 int Hstart = 1;
 652                 int Hend = Hstart + winWidth;
 653 DEBUG(printk(KERN_DEBUG "       Y: scale=0, start=%d, end=%d\n", Hstart, Hend));
 654                 zraor((Hstart<<10)|(Hend<<0),~(ZORAN_VFEH_HSTART|ZORAN_VFEH_HEND),ZORAN_VFEH);
 655         }
 656         else {
 657                 int Wa = maxWidth;
 658                 int X = (winWidth*64+Wa-1)/Wa;
 659                 int We = winWidth*64/X;
 660                 int HorDcm = 64-X;
 661                 int hcrop1 = 2*(Wa-We)/4;
 662                 /*
 663                  * BUGFIX: Juha Nurmela <junki@qn-lpr2-165.quicknet.inet.fi>
 664                  * found the solution to the color phase shift.
 665                  * See ChangeLog for the full explanation)
 666                  */
 667                 int Hstart = (maxXOffset + hcrop1) | 1;
 668                 int Hend = Hstart + We - 1;
 669
 670 DEBUG(printk(KERN_DEBUG "       X: scale=%d, start=%d, end=%d\n", HorDcm, Hstart, Hend));
 671
 672                 zraor((Hstart<<10)|(Hend<<0),~(ZORAN_VFEH_HSTART|ZORAN_VFEH_HEND),ZORAN_VFEH);
 673                 vfec |= HorDcm<<14;
 674
 675                 if (HorDcm<16)
 676                         vfec |= ZORAN_VFEC_HFILTER_1; /* no filter */
 677                 else if (HorDcm<32)
 678                         vfec |= ZORAN_VFEC_HFILTER_3; /* 3 tap filter */
 679                 else if (HorDcm<48)
 680                         vfec |= ZORAN_VFEC_HFILTER_4; /* 4 tap filter */
 681                 else    vfec |= ZORAN_VFEC_HFILTER_5; /* 5 tap filter */
 682         }
 683
 684         /*
 685          * Determine vertical scales and crops
 686          *
 687          * when height is negative, we want to read starting at line 0
 688          * One day someone might need access to these lines...
 689          */
 690         if (i->h < 0) {
 691                 int Vstart = 0;
 692                 int Vend = Vstart + winHeight;
 693 DEBUG(printk(KERN_DEBUG "       Y: scale=0, start=%d, end=%d\n", Vstart, Vend));
 694                 zraor((Vstart<<10)|(Vend<<0),~(ZORAN_VFEV_VSTART|ZORAN_VFEV_VEND),ZORAN_VFEV);
 695         }
 696         else {
 697                 int Ha = maxHeight;
 698                 int Y = (winHeight*64+Ha-1)/Ha;
 699                 int He = winHeight*64/Y;
 700                 int VerDcm = 64-Y;
 701                 int vcrop1 = 2*(Ha-He)/4;
 702                 int Vstart = maxYOffset + vcrop1;
 703                 int Vend = Vstart + He - 1;
 704
 705 DEBUG(printk(KERN_DEBUG "       Y: scale=%d, start=%d, end=%d\n", VerDcm, Vstart, Vend));
 706                 zraor((Vstart<<10)|(Vend<<0),~(ZORAN_VFEV_VSTART|ZORAN_VFEV_VEND),ZORAN_VFEV);
 707                 vfec |= VerDcm<<8;
 708         }
 709
 710 DEBUG(printk(KERN_DEBUG "       F: format=%d(=%s)\n",i->format,palette2fmt[i->format].name));
 711
 712         /* setup the requested format */
 713         zrwrite(vfec, ZORAN_VFEC);
 714 }
 715
 716 static
 717 void zoran_common_open(struct zoran* ztv, int flags)
 718 {
 719         UNUSED(flags);
 720
 721         /* already opened? */
 722         if (ztv->users++ != 0)
 723                 return;
 724
 725         /* unmute audio */
 726         /* /what/ audio? */
 727
 728         ztv->state = 0;
 729
 730         /* setup the encoder to the initial values */
 731         ztv->picture.colour=254<<7;
 732         ztv->picture.brightness=128<<8;
 733         ztv->picture.hue=128<<8;
 734         ztv->picture.contrast=216<<7;
 735         i2c_control_device(&ztv->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_PICTURE, &ztv->picture);
 736
 737         /* default to the composite input since my camera is there */
 738         zoran_muxsel(ztv, 0, VIDEO_MODE_PAL);
 739 }
 740
 741 static
 742 void zoran_common_close(struct zoran* ztv)
 743 {
 744         if (--ztv->users != 0)
 745                 return;
 746
 747         /* mute audio */
 748         /* /what/ audio? */
 749
 750         /* stop the chip */
 751         zoran_cap(ztv, 0);
 752 }
 753
 754 /*
 755  * Open a zoran card. Right now the flags are just a hack
 756  */
 757 static int zoran_open(struct video_device *dev, int flags)
 758 {
 759         struct zoran *ztv = (struct zoran*)dev;
 760         struct vidinfo* item;
 761         char* pos;
 762
 763         DEBUG(printk(CARD_DEBUG "open(dev,%d)\n",CARD,flags));
 764
 765         /*********************************************
 766          * We really should be doing lazy allocing...
 767          *********************************************/
 768         /* allocate a frame buffer */
 769         if (!ztv->fbuffer)
 770                 ztv->fbuffer = bmalloc(ZORAN_MAX_FBUFSIZE);
 771         if (!ztv->fbuffer) {
 772                 /* could not get a buffer, bail out */
 773                 return -ENOBUFS;
 774         }
 775         /* at this time we _always_ have a framebuffer */
 776         memset(ztv->fbuffer,0,ZORAN_MAX_FBUFSIZE);
 777
 778         if (!ztv->overinfo.overlay)
 779                 ztv->overinfo.overlay = kmalloc(1024*1024/8, GFP_KERNEL);
 780         if (!ztv->overinfo.overlay) {
 781                 /* could not get an overlay buffer, bail out */
 782                 bfree(ztv->fbuffer, ZORAN_MAX_FBUFSIZE);
 783                 return -ENOBUFS;
 784         }
 785         /* at this time we _always_ have a overlay */
 786
 787         /* clear buffer status, and give them a DMAable address */
 788         pos = ztv->fbuffer;
 789         for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
 790         {
 791                 item->status = FBUFFER_FREE;
 792                 item->memadr = pos;
 793                 item->busadr = virt_to_bus(pos);
 794                 pos += ZORAN_MAX_FBUFFER;
 795         }
 796
 797         /* do the common part of all open's */
 798         zoran_common_open(ztv, flags);
 799
 800         return 0;
 801 }
 802
 803 static
 804 void zoran_close(struct video_device* dev)
 805 {
 806         struct zoran *ztv = (struct zoran*)dev;
 807
 808         DEBUG(printk(CARD_DEBUG "close(dev)\n",CARD));
 809
 810         /* driver specific closure */
 811         clear_bit(STATE_OVERLAY, &ztv->state);
 812
 813         zoran_common_close(ztv);
 814
 815         /*
 816          *      This is sucky but right now I can't find a good way to
 817          *      be sure its safe to free the buffer. We wait 5-6 fields
 818          *      which is more than sufficient to be sure.
 819          */
 820         msleep(100);                    /* Wait 1/10th of a second */
 821
 822         /* free the allocated framebuffer */
 823         if (ztv->fbuffer)
 824                 bfree( ztv->fbuffer, ZORAN_MAX_FBUFSIZE );
 825         ztv->fbuffer = 0;
 826         if (ztv->overinfo.overlay)
 827                 kfree( ztv->overinfo.overlay );
 828         ztv->overinfo.overlay = 0;
 829
 830 }
 831
 832 /*
 833  * This read function could be used reentrant in a SMP situation.
 834  *
 835  * This is made possible by the spinlock which is kept till we
 836  * found and marked a buffer for our own use. The lock must
 837  * be released as soon as possible to prevent lock contention.
 838  */
 839 static
 840 long zoran_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
 841 {
 842         struct zoran *ztv = (struct zoran*)dev;
 843         unsigned long max;
 844         struct vidinfo* unused = 0;
 845         struct vidinfo* done = 0;
 846
 847         DEBUG(printk(CARD_DEBUG "zoran_read(%p,%ld,%d)\n",CARD,buf,count,nonblock));
 848
 849         /* find ourself a free or completed buffer */
 850         for (;;) {
 851                 struct vidinfo* item;
 852
 853                 write_lock_irq(&ztv->lock);
 854                 for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
 855                 {
 856                         if (!unused && item->status == FBUFFER_FREE)
 857                                 unused = item;
 858                         if (!done && item->status == FBUFFER_DONE)
 859                                 done = item;
 860                 }
 861                 if (done || unused)
 862                         break;
 863
 864                 /* no more free buffers, wait for them. */
 865                 write_unlock_irq(&ztv->lock);
 866                 if (nonblock)
 867                         return -EWOULDBLOCK;
 868                 interruptible_sleep_on(&ztv->grabq);
 869                 if (signal_pending(current))
 870                         return -EINTR;
 871         }
 872
 873         /* Do we have 'ready' data? */
 874         if (!done) {
 875                 /* no? than this will take a while... */
 876                 if (nonblock) {
 877                         write_unlock_irq(&ztv->lock);
 878                         return -EWOULDBLOCK;
 879                 }
 880
 881                 /* mark the unused buffer as wanted */
 882                 unused->status = FBUFFER_BUSY;
 883                 unused->w = 320;
 884                 unused->h = 240;
 885                 unused->format = VIDEO_PALETTE_RGB24;
 886                 unused->bpp = palette2fmt[unused->format].bpp;
 887                 unused->bpl = unused->w * unused->bpp;
 888                 unused->next = 0;
 889                 { /* add to tail of queue */
 890                   struct vidinfo* oldframe = ztv->workqueue;
 891                   if (!oldframe) ztv->workqueue = unused;
 892                   else {
 893                     while (oldframe->next) oldframe = oldframe->next;
 894                     oldframe->next = unused;
 895                   }
 896                 }
 897                 write_unlock_irq(&ztv->lock);
 898
 899                 /* tell the state machine we want it filled /NOW/ */
 900                 zoran_cap(ztv, 1);
 901
 902                 /* wait till this buffer gets grabbed */
 903                 wait_event_interruptible(ztv->grabq,
 904                                 (unused->status != FBUFFER_BUSY));
 905                 /* see if a signal did it */
 906                 if (signal_pending(current))
 907                         return -EINTR;
 908                 done = unused;
 909         }
 910         else
 911                 write_unlock_irq(&ztv->lock);
 912
 913         /* Yes! we got data! */
 914         max = done->bpl * done->h;
 915         if (count > max)
 916                 count = max;
 917         if (copy_to_user((void*)buf, done->memadr, count))
 918                 count = -EFAULT;
 919
 920         /* keep the engine running */
 921         done->status = FBUFFER_FREE;
 922 //      zoran_cap(ztv,1);
 923
 924         /* tell listeners this buffer became free */
 925         wake_up_interruptible(&ztv->grabq);
 926
 927         /* goodbye */
 928         DEBUG(printk(CARD_DEBUG "zoran_read() returns %lu\n",CARD,count));
 929         return count;
 930 }
 931
 932 static
 933 long zoran_write(struct video_device* dev, const char* buf, unsigned long count, int nonblock)
 934 {
 935         struct zoran *ztv = (struct zoran *)dev;
 936         UNUSED(ztv); UNUSED(dev); UNUSED(buf); UNUSED(count); UNUSED(nonblock);
 937         DEBUG(printk(CARD_DEBUG "zoran_write\n",CARD));
 938         return -EINVAL;
 939 }
 940
 941 static
 942 unsigned int zoran_poll(struct video_device *dev, struct file *file, poll_table *wait)
 943 {
 944         struct zoran *ztv = (struct zoran *)dev;
 945         struct vidinfo* item;
 946         unsigned int mask = 0;
 947
 948         poll_wait(file, &ztv->grabq, wait);
 949
 950         for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
 951                 if (item->status == FBUFFER_DONE)
 952                 {
 953                         mask |= (POLLIN | POLLRDNORM);
 954                         break;
 955                 }
 956
 957         DEBUG(printk(CARD_DEBUG "zoran_poll()=%x\n",CARD,mask));
 958
 959         return mask;
 960 }
 961
 962 /* append a new clipregion to the vector of video_clips */
 963 static
 964 void new_clip(struct video_window* vw, struct video_clip* vcp, int x, int y, int w, int h)
 965 {
 966         vcp[vw->clipcount].x = x;
 967         vcp[vw->clipcount].y = y;
 968         vcp[vw->clipcount].width = w;
 969         vcp[vw->clipcount].height = h;
 970         vw->clipcount++;
 971 }
 972
 973 static
 974 int zoran_ioctl(struct video_device* dev, unsigned int cmd, void *arg)
 975 {
 976         struct zoran* ztv = (struct zoran*)dev;
 977
 978         switch (cmd) {
 979          case VIDIOCGCAP:
 980          {
 981                 struct video_capability c;
 982                 DEBUG(printk(CARD_DEBUG "VIDIOCGCAP\n",CARD));
 983
 984                 strcpy(c.name,ztv->video_dev.name);
 985                 c.type = VID_TYPE_CAPTURE|
 986                          VID_TYPE_OVERLAY|
 987                          VID_TYPE_CLIPPING|
 988                          VID_TYPE_FRAMERAM|
 989                          VID_TYPE_SCALES;
 990                 if (ztv->have_tuner)
 991                         c.type |= VID_TYPE_TUNER;
 992                 if (ztv->have_decoder) {
 993                         c.channels = ztv->card->video_inputs;
 994                         c.audios = ztv->card->audio_inputs;
 995                 } else
 996                         /* no decoder -> no channels */
 997                         c.channels = c.audios = 0;
 998                 c.maxwidth = 768;
 999                 c.maxheight = 576;
1000                 c.minwidth = 32;
1001                 c.minheight = 32;
1002                 if (copy_to_user(arg,&c,sizeof(c)))
1003                         return -EFAULT;
1004                 break;
1005          }
1006
1007          case VIDIOCGCHAN:
1008          {
1009                 struct video_channel v;
1010                 int mux;
1011                 if (copy_from_user(&v, arg,sizeof(v)))
1012                         return -EFAULT;
1013                 DEBUG(printk(CARD_DEBUG "VIDIOCGCHAN(%d)\n",CARD,v.channel));
1014                 v.flags=VIDEO_VC_AUDIO
1015 #ifdef VIDEO_VC_NORM
1016                         |VIDEO_VC_NORM
1017 #endif
1018                         ;
1019                 v.tuners=0;
1020                 v.type=VIDEO_TYPE_CAMERA;
1021 #ifdef I_EXPECT_POSSIBLE_NORMS_IN_THE_API
1022                 v.norm=VIDEO_MODE_PAL|
1023                        VIDEO_MODE_NTSC|
1024                        VIDEO_MODE_SECAM;
1025 #else
1026                 v.norm=VIDEO_MODE_PAL;
1027 #endif
1028                 /* too many inputs? no decoder -> no channels */
1029                 if (!ztv->have_decoder || v.channel < 0 ||  v.channel >= ztv->card->video_inputs)
1030                         return -EINVAL;
1031
1032                 /* now determine the name of the channel */
1033                 mux = ztv->card->video_mux[v.channel];
1034                 if (mux & IS_TUNER) {
1035                         /* lets assume only one tuner, yes? */
1036                         strcpy(v.name,"Television");
1037                         v.type = VIDEO_TYPE_TV;
1038                         if (ztv->have_tuner) {
1039                                 v.flags |= VIDEO_VC_TUNER;
1040                                 v.tuners = 1;
1041                         }
1042                 }
1043                 else if (mux & IS_SVHS)
1044                         sprintf(v.name,"S-Video-%d",v.channel);
1045                 else
1046                         sprintf(v.name,"CVBS-%d",v.channel);
1047
1048                 if (copy_to_user(arg,&v,sizeof(v)))
1049                         return -EFAULT;
1050                 break;
1051          }
1052          case VIDIOCSCHAN:
1053          {      /* set video channel */
1054                 struct video_channel v;
1055                 if (copy_from_user(&v, arg,sizeof(v)))
1056                         return -EFAULT;
1057                 DEBUG(printk(CARD_DEBUG "VIDIOCSCHAN(%d,%d)\n",CARD,v.channel,v.norm));
1058
1059                 /* too many inputs? no decoder -> no channels */
1060                 if (!ztv->have_decoder || v.channel >= ztv->card->video_inputs || v.channel < 0)
1061                         return -EINVAL;
1062
1063                 if (v.norm != VIDEO_MODE_PAL &&
1064                     v.norm != VIDEO_MODE_NTSC &&
1065                     v.norm != VIDEO_MODE_SECAM &&
1066                     v.norm != VIDEO_MODE_AUTO)
1067                         return -EOPNOTSUPP;
1068
1069                 /* make it happen, nr1! */
1070                 return zoran_muxsel(ztv,v.channel,v.norm);
1071          }
1072
1073          case VIDIOCGTUNER:
1074          {
1075                 struct video_tuner v;
1076                 if (copy_from_user(&v, arg,sizeof(v)))
1077                         return -EFAULT;
1078                 DEBUG(printk(CARD_DEBUG "VIDIOCGTUNER(%d)\n",CARD,v.tuner));
1079
1080                 /* Only no or one tuner for now */
1081                 if (!ztv->have_tuner || v.tuner)
1082                         return -EINVAL;
1083
1084                 strcpy(v.name,"Television");
1085                 v.rangelow  = 0;
1086                 v.rangehigh = ~0;
1087                 v.flags     = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1088                 v.mode      = ztv->norm;
1089                 v.signal    = 0xFFFF; /* unknown */
1090
1091                 if (copy_to_user(arg,&v,sizeof(v)))
1092                         return -EFAULT;
1093                 break;
1094          }
1095          case VIDIOCSTUNER:
1096          {
1097                 struct video_tuner v;
1098                 if (copy_from_user(&v, arg, sizeof(v)))
1099                         return -EFAULT;
1100                 DEBUG(printk(CARD_DEBUG "VIDIOCSTUNER(%d,%d)\n",CARD,v.tuner,v.mode));
1101
1102                 /* Only no or one tuner for now */
1103                 if (!ztv->have_tuner || v.tuner)
1104                         return -EINVAL;
1105
1106                 /* and it only has certain valid modes */
1107                 if( v.mode != VIDEO_MODE_PAL &&
1108                     v.mode != VIDEO_MODE_NTSC &&
1109                     v.mode != VIDEO_MODE_SECAM)
1110                         return -EOPNOTSUPP;
1111
1112                 /* engage! */
1113                 return zoran_muxsel(ztv,v.tuner,v.mode);
1114          }
1115
1116          case VIDIOCGPICT:
1117          {
1118                 struct video_picture p = ztv->picture;
1119                 DEBUG(printk(CARD_DEBUG "VIDIOCGPICT\n",CARD));
1120                 p.depth = ztv->depth;
1121                 switch (p.depth) {
1122                  case  8: p.palette=VIDEO_PALETTE_YUV422;
1123                           break;
1124                  case 15: p.palette=VIDEO_PALETTE_RGB555;
1125                           break;
1126                  case 16: p.palette=VIDEO_PALETTE_RGB565;
1127                           break;
1128                  case 24: p.palette=VIDEO_PALETTE_RGB24;
1129                           break;
1130                  case 32: p.palette=VIDEO_PALETTE_RGB32;
1131                           break;
1132                 }
1133                 if (copy_to_user(arg, &p, sizeof(p)))
1134                         return -EFAULT;
1135                 break;
1136          }
1137          case VIDIOCSPICT:
1138          {
1139                 struct video_picture p;
1140                 if (copy_from_user(&p, arg,sizeof(p)))
1141                         return -EFAULT;
1142                 DEBUG(printk(CARD_DEBUG "VIDIOCSPICT(%d,%d,%d,%d,%d,%d,%d)\n",CARD,p.brightness,p.hue,p.colour,p.contrast,p.whiteness,p.depth,p.palette));
1143
1144                 /* depth must match with framebuffer */
1145                 if (p.depth != ztv->depth)
1146                         return -EINVAL;
1147
1148                 /* check if palette matches this bpp */
1149                 if (p.palette>NRPALETTES ||
1150                     palette2fmt[p.palette].bpp != ztv->overinfo.bpp)
1151                         return -EINVAL;
1152
1153                 write_lock_irq(&ztv->lock);
1154                 ztv->overinfo.format = p.palette;
1155                 ztv->picture = p;
1156                 write_unlock_irq(&ztv->lock);
1157
1158                 /* tell the decoder */
1159                 i2c_control_device(&ztv->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_PICTURE, &p);
1160                 break;
1161          }
1162
1163          case VIDIOCGWIN:
1164          {
1165                 struct video_window vw;
1166                 DEBUG(printk(CARD_DEBUG "VIDIOCGWIN\n",CARD));
1167                 read_lock(&ztv->lock);
1168                 vw.x      = ztv->overinfo.x;
1169                 vw.y      = ztv->overinfo.y;
1170                 vw.width  = ztv->overinfo.w;
1171                 vw.height = ztv->overinfo.h;
1172                 vw.chromakey= 0;
1173                 vw.flags  = 0;
1174                 if (ztv->vidInterlace)
1175                         vw.flags|=VIDEO_WINDOW_INTERLACE;
1176                 read_unlock(&ztv->lock);
1177                 if (copy_to_user(arg,&vw,sizeof(vw)))
1178                         return -EFAULT;
1179                 break;
1180          }
1181          case VIDIOCSWIN:
1182          {
1183                 struct video_window vw;
1184                 struct video_clip *vcp;
1185                 int on;
1186                 if (copy_from_user(&vw,arg,sizeof(vw)))
1187                         return -EFAULT;
1188                 DEBUG(printk(CARD_DEBUG "VIDIOCSWIN(%d,%d,%d,%d,%x,%d)\n",CARD,vw.x,vw.y,vw.width,vw.height,vw.flags,vw.clipcount));
1189
1190                 if (vw.flags)
1191                         return -EINVAL;
1192
1193                 if (vw.clipcount <0 || vw.clipcount>256)
1194                         return -EDOM;   /* Too many! */
1195
1196                 /*
1197                  *      Do any clips.
1198                  */
1199                 vcp = vmalloc(sizeof(struct video_clip)*(vw.clipcount+4));
1200                 if (vcp==NULL)
1201                         return -ENOMEM;
1202                 if (vw.clipcount && copy_from_user(vcp,vw.clips,sizeof(struct video_clip)*vw.clipcount)) {
1203                         vfree(vcp);
1204                         return -EFAULT;
1205                 }
1206
1207                 on = ztv->running;
1208                 if (on)
1209                         zoran_cap(ztv, 0);
1210
1211                 /*
1212                  * strange, it seems xawtv sometimes calls us with 0
1213                  * width and/or height. Ignore these values
1214                  */
1215                 if (vw.x == 0)
1216                         vw.x = ztv->overinfo.x;
1217                 if (vw.y == 0)
1218                         vw.y = ztv->overinfo.y;
1219
1220                 /* by now we are committed to the new data... */
1221                 write_lock_irq(&ztv->lock);
1222                 ztv->overinfo.x = vw.x;
1223                 ztv->overinfo.y = vw.y;
1224                 ztv->overinfo.w = vw.width;
1225                 ztv->overinfo.h = vw.height;
1226                 write_unlock_irq(&ztv->lock);
1227
1228                 /*
1229                  *      Impose display clips
1230                  */
1231                 if (vw.x+vw.width > ztv->swidth)
1232                         new_clip(&vw, vcp, ztv->swidth-vw.x, 0, vw.width-1, vw.height-1);
1233                 if (vw.y+vw.height > ztv->sheight)
1234                         new_clip(&vw, vcp, 0, ztv->sheight-vw.y, vw.width-1, vw.height-1);
1235
1236                 /* built the requested clipping zones */
1237                 zoran_set_geo(ztv, &ztv->overinfo);
1238                 zoran_built_overlay(ztv, vw.clipcount, vcp);
1239                 vfree(vcp);
1240
1241                 /* if we were on, restart the video engine */
1242                 if (on)
1243                         zoran_cap(ztv, 1);
1244                 break;
1245          }
1246
1247          case VIDIOCCAPTURE:
1248          {
1249                 int v;
1250                 if (get_user(v, (int *)arg))
1251                         return -EFAULT;
1252                 DEBUG(printk(CARD_DEBUG "VIDIOCCAPTURE(%d)\n",CARD,v));
1253
1254                 if (v==0) {
1255                         clear_bit(STATE_OVERLAY, &ztv->state);
1256                         zoran_cap(ztv, 1);
1257                 }
1258                 else {
1259                         /* is VIDIOCSFBUF, VIDIOCSWIN done? */
1260                         if (ztv->overinfo.busadr==0 || ztv->overinfo.w==0 || ztv->overinfo.h==0)
1261                                 return -EINVAL;
1262
1263                         set_bit(STATE_OVERLAY, &ztv->state);
1264                         zoran_cap(ztv, 1);
1265                 }
1266                 break;
1267          }
1268
1269          case VIDIOCGFBUF:
1270          {
1271                 struct video_buffer v;
1272                 DEBUG(printk(CARD_DEBUG "VIDIOCGFBUF\n",CARD));
1273                 read_lock(&ztv->lock);
1274                 v.base   = (void *)ztv->overinfo.busadr;
1275                 v.height = ztv->sheight;
1276                 v.width  = ztv->swidth;
1277                 v.depth  = ztv->depth;
1278                 v.bytesperline = ztv->overinfo.bpl;
1279                 read_unlock(&ztv->lock);
1280                 if(copy_to_user(arg, &v,sizeof(v)))
1281                         return -EFAULT;
1282                 break;
1283          }
1284          case VIDIOCSFBUF:
1285          {
1286                 struct video_buffer v;
1287                 if(!capable(CAP_SYS_ADMIN))
1288                         return -EPERM;
1289                 if (copy_from_user(&v, arg,sizeof(v)))
1290                         return -EFAULT;
1291                 DEBUG(printk(CARD_DEBUG "VIDIOCSFBUF(%p,%d,%d,%d,%d)\n",CARD,v.base, v.width,v.height,v.depth,v.bytesperline));
1292
1293                 if (v.depth!=15 && v.depth!=16 && v.depth!=24 && v.depth!=32)
1294                         return -EINVAL;
1295                 if (v.bytesperline<1)
1296                         return -EINVAL;
1297                 if (ztv->running)
1298                         return -EBUSY;
1299                 write_lock_irq(&ztv->lock);
1300                 ztv->overinfo.busadr  = (ulong)v.base;
1301                 ztv->sheight      = v.height;
1302                 ztv->swidth       = v.width;
1303                 ztv->depth        = v.depth;            /* bits per pixel */
1304                 ztv->overinfo.bpp = ((v.depth+1)&0x38)/8;/* bytes per pixel */
1305                 ztv->overinfo.bpl = v.bytesperline;     /* bytes per line */
1306                 write_unlock_irq(&ztv->lock);
1307                 break;
1308          }
1309
1310          case VIDIOCKEY:
1311          {
1312                 /* Will be handled higher up .. */
1313                 break;
1314          }
1315
1316          case VIDIOCSYNC:
1317          {
1318                 int i;
1319                 if (get_user(i, (int *) arg))
1320                         return -EFAULT;
1321                 DEBUG(printk(CARD_DEBUG "VIDEOCSYNC(%d)\n",CARD,i));
1322                 if (i<0 || i>ZORAN_MAX_FBUFFERS)
1323                         return -EINVAL;
1324                 switch (ztv->grabinfo[i].status) {
1325                  case FBUFFER_FREE:
1326                         return -EINVAL;
1327                  case FBUFFER_BUSY:
1328                         /* wait till this buffer gets grabbed */
1329                         wait_event_interruptible(ztv->grabq,
1330                                         (ztv->grabinfo[i].status != FBUFFER_BUSY));
1331                         /* see if a signal did it */
1332                         if (signal_pending(current))
1333                                 return -EINTR;
1334                         /* don't fall through; a DONE buffer is not UNUSED */
1335                         break;
1336                  case FBUFFER_DONE:
1337                         ztv->grabinfo[i].status = FBUFFER_FREE;
1338                         /* tell ppl we have a spare buffer */
1339                         wake_up_interruptible(&ztv->grabq);
1340                         break;
1341                 }
1342                 DEBUG(printk(CARD_DEBUG "VIDEOCSYNC(%d) returns\n",CARD,i));
1343                 break;
1344          }
1345
1346          case VIDIOCMCAPTURE:
1347          {
1348                 struct video_mmap vm;
1349                 struct vidinfo* frame;
1350                 if (copy_from_user(&vm,arg,sizeof(vm)))
1351                         return -EFAULT;
1352                 DEBUG(printk(CARD_DEBUG "VIDIOCMCAPTURE(%d,(%d,%d),%d)\n",CARD,vm.frame,vm.width,vm.height,vm.format));
1353                 if (vm.frame<0 || vm.frame>ZORAN_MAX_FBUFFERS ||
1354                     vm.width<32 || vm.width>768 ||
1355                     vm.height<32 || vm.height>576 ||
1356                     vm.format>NRPALETTES ||
1357                     palette2fmt[vm.format].mode == 0)
1358                         return -EINVAL;
1359
1360                 /* we are allowed to take over UNUSED and DONE buffers */
1361                 frame = &ztv->grabinfo[vm.frame];
1362                 if (frame->status == FBUFFER_BUSY)
1363                         return -EBUSY;
1364
1365                 /* setup the other parameters if they are given */
1366                 write_lock_irq(&ztv->lock);
1367                 frame->w = vm.width;
1368                 frame->h = vm.height;
1369                 frame->format = vm.format;
1370                 frame->bpp = palette2fmt[frame->format].bpp;
1371                 frame->bpl = frame->w*frame->bpp;
1372                 frame->status = FBUFFER_BUSY;
1373                 frame->next = 0;
1374                 { /* add to tail of queue */
1375                   struct vidinfo* oldframe = ztv->workqueue;
1376                   if (!oldframe) ztv->workqueue = frame;
1377                   else {
1378                     while (oldframe->next) oldframe = oldframe->next;
1379                     oldframe->next = frame;
1380                   }
1381                 }
1382                 write_unlock_irq(&ztv->lock);
1383                 zoran_cap(ztv, 1);
1384                 break;
1385          }
1386
1387          case VIDIOCGMBUF:
1388          {
1389                 struct video_mbuf mb;
1390                 int i;
1391                 DEBUG(printk(CARD_DEBUG "VIDIOCGMBUF\n",CARD));
1392                 mb.size = ZORAN_MAX_FBUFSIZE;
1393                 mb.frames = ZORAN_MAX_FBUFFERS;
1394                 for (i=0; i<ZORAN_MAX_FBUFFERS; i++)
1395                         mb.offsets[i] = i*ZORAN_MAX_FBUFFER;
1396                 if(copy_to_user(arg, &mb,sizeof(mb)))
1397                         return -EFAULT;
1398                 break;
1399          }
1400
1401          case VIDIOCGUNIT:
1402          {
1403                 struct video_unit vu;
1404                 DEBUG(printk(CARD_DEBUG "VIDIOCGUNIT\n",CARD));
1405                 vu.video = ztv->video_dev.minor;
1406                 vu.vbi = ztv->vbi_dev.minor;
1407                 vu.radio = VIDEO_NO_UNIT;
1408                 vu.audio = VIDEO_NO_UNIT;
1409                 vu.teletext = VIDEO_NO_UNIT;
1410                 if(copy_to_user(arg, &vu,sizeof(vu)))
1411                         return -EFAULT;
1412                 break;
1413          }
1414
1415          case VIDIOCGFREQ:
1416          {
1417                 unsigned long v = ztv->tuner_freq;
1418                 if (copy_to_user(arg,&v,sizeof(v)))
1419                         return -EFAULT;
1420                 DEBUG(printk(CARD_DEBUG "VIDIOCGFREQ\n",CARD));
1421                 break;
1422          }
1423          case VIDIOCSFREQ:
1424          {
1425                 unsigned long v;
1426                 if (copy_from_user(&v, arg, sizeof(v)))
1427                         return -EFAULT;
1428                 DEBUG(printk(CARD_DEBUG "VIDIOCSFREQ\n",CARD));
1429
1430                 if (ztv->have_tuner) {
1431                         int fixme = v;
1432                         if (i2c_control_device(&(ztv->i2c), I2C_DRIVERID_TUNER, TUNER_SET_TVFREQ, &fixme) < 0)
1433                                 return -EAGAIN;
1434                 }
1435                 ztv->tuner_freq = v;
1436                 break;
1437          }
1438
1439          /* Why isn't this in the API?
1440           * And why doesn't it take a buffer number?
1441          case BTTV_FIELDNR:
1442          {
1443                 unsigned long v = ztv->lastfieldnr;
1444                 if (copy_to_user(arg,&v,sizeof(v)))
1445                         return -EFAULT;
1446                 DEBUG(printk(CARD_DEBUG "BTTV_FIELDNR\n",CARD));
1447                 break;
1448          }
1449          */
1450
1451          default:
1452                 return -ENOIOCTLCMD;
1453         }
1454         return 0;
1455 }
1456
1457 static
1458 int zoran_mmap(struct vm_area_struct *vma, struct video_device* dev, const char* adr, unsigned long size)
1459 {
1460         struct zoran* ztv = (struct zoran*)dev;
1461         unsigned long start = (unsigned long)adr;
1462         unsigned long pos;
1463
1464         DEBUG(printk(CARD_DEBUG "zoran_mmap(0x%p,%ld)\n",CARD,adr,size));
1465
1466         /* sanity checks */
1467         if (size > ZORAN_MAX_FBUFSIZE || !ztv->fbuffer)
1468                 return -EINVAL;
1469
1470         /* start mapping the whole shabang to user memory */
1471         pos = (unsigned long)ztv->fbuffer;
1472         while (size>0) {
1473                 unsigned long pfn = virt_to_phys((void*)pos) >> PAGE_SHIFT;
1474                 if (remap_pfn_range(vma, start, pfn, PAGE_SIZE, PAGE_SHARED))
1475                         return -EAGAIN;
1476                 start += PAGE_SIZE;
1477                 pos += PAGE_SIZE;
1478                 size -= PAGE_SIZE;
1479         }
1480         return 0;
1481 }
1482
1483 static struct video_device zr36120_template=
1484 {
1485         .owner          = THIS_MODULE,
1486         .name           = "UNSET",
1487         .type           = VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY,
1488         .hardware       = VID_HARDWARE_ZR36120,
1489         .open           = zoran_open,
1490         .close          = zoran_close,
1491         .read           = zoran_read,
1492         .write          = zoran_write,
1493         .poll           = zoran_poll,
1494         .ioctl          = zoran_ioctl,
1495         .mmap           = zoran_mmap,
1496         .minor          = -1,
1497 };
1498
1499 static
1500 int vbi_open(struct video_device *dev, int flags)
1501 {
1502         struct zoran *ztv = dev->priv;
1503         struct vidinfo* item;
1504
1505         DEBUG(printk(CARD_DEBUG "vbi_open(dev,%d)\n",CARD,flags));
1506
1507         /*
1508          * During VBI device open, we continiously grab VBI-like
1509          * data in the vbi buffer when we have nothing to do.
1510          * Only when there is an explicit request for VBI data
1511          * (read call) we /force/ a read.
1512          */
1513
1514         /* allocate buffers */
1515         for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
1516         {
1517                 item->status = FBUFFER_FREE;
1518
1519                 /* alloc */
1520                 if (!item->memadr) {
1521                         item->memadr = bmalloc(ZORAN_VBI_BUFSIZE);
1522                         if (!item->memadr) {
1523                                 /* could not get a buffer, bail out */
1524                                 while (item != ztv->readinfo) {
1525                                         item--;
1526                                         bfree(item->memadr, ZORAN_VBI_BUFSIZE);
1527                                         item->memadr = 0;
1528                                         item->busadr = 0;
1529                                 }
1530                                 return -ENOBUFS;
1531                         }
1532                 }
1533
1534                 /* determine the DMAable address */
1535                 item->busadr = virt_to_bus(item->memadr);
1536         }
1537
1538         /* do the common part of all open's */
1539         zoran_common_open(ztv, flags);
1540
1541         set_bit(STATE_VBI, &ztv->state);
1542         /* start read-ahead */
1543         zoran_cap(ztv, 1);
1544
1545         return 0;
1546 }
1547
1548 static
1549 void vbi_close(struct video_device *dev)
1550 {
1551         struct zoran *ztv = dev->priv;
1552         struct vidinfo* item;
1553
1554         DEBUG(printk(CARD_DEBUG "vbi_close(dev)\n",CARD));
1555
1556         /* driver specific closure */
1557         clear_bit(STATE_VBI, &ztv->state);
1558
1559         zoran_common_close(ztv);
1560
1561         /*
1562          *      This is sucky but right now I can't find a good way to
1563          *      be sure its safe to free the buffer. We wait 5-6 fields
1564          *      which is more than sufficient to be sure.
1565          */
1566         msleep(100);                    /* Wait 1/10th of a second */
1567
1568         for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
1569         {
1570                 if (item->memadr)
1571                         bfree(item->memadr, ZORAN_VBI_BUFSIZE);
1572                 item->memadr = 0;
1573         }
1574
1575 }
1576
1577 /*
1578  * This read function could be used reentrant in a SMP situation.
1579  *
1580  * This is made possible by the spinlock which is kept till we
1581  * found and marked a buffer for our own use. The lock must
1582  * be released as soon as possible to prevent lock contention.
1583  */
1584 static
1585 long vbi_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
1586 {
1587         struct zoran *ztv = dev->priv;
1588         unsigned long max;
1589         struct vidinfo* unused = 0;
1590         struct vidinfo* done = 0;
1591
1592         DEBUG(printk(CARD_DEBUG "vbi_read(0x%p,%ld,%d)\n",CARD,buf,count,nonblock));
1593
1594         /* find ourself a free or completed buffer */
1595         for (;;) {
1596                 struct vidinfo* item;
1597
1598                 write_lock_irq(&ztv->lock);
1599                 for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++) {
1600                         if (!unused && item->status == FBUFFER_FREE)
1601                                 unused = item;
1602                         if (!done && item->status == FBUFFER_DONE)
1603                                 done = item;
1604                 }
1605                 if (done || unused)
1606                         break;
1607
1608                 /* no more free buffers, wait for them. */
1609                 write_unlock_irq(&ztv->lock);
1610                 if (nonblock)
1611                         return -EWOULDBLOCK;
1612                 interruptible_sleep_on(&ztv->vbiq);
1613                 if (signal_pending(current))
1614                         return -EINTR;
1615         }
1616
1617         /* Do we have 'ready' data? */
1618         if (!done) {
1619                 /* no? than this will take a while... */
1620                 if (nonblock) {
1621                         write_unlock_irq(&ztv->lock);
1622                         return -EWOULDBLOCK;
1623                 }
1624
1625                 /* mark the unused buffer as wanted */
1626                 unused->status = FBUFFER_BUSY;
1627                 unused->next = 0;
1628                 { /* add to tail of queue */
1629                   struct vidinfo* oldframe = ztv->workqueue;
1630                   if (!oldframe) ztv->workqueue = unused;
1631                   else {
1632                     while (oldframe->next) oldframe = oldframe->next;
1633                     oldframe->next = unused;
1634                   }
1635                 }
1636                 write_unlock_irq(&ztv->lock);
1637
1638                 /* tell the state machine we want it filled /NOW/ */
1639                 zoran_cap(ztv, 1);
1640
1641                 /* wait till this buffer gets grabbed */
1642                 wait_event_interruptible(ztv->vbiq,
1643                                 (unused->status != FBUFFER_BUSY));
1644                 /* see if a signal did it */
1645                 if (signal_pending(current))
1646                         return -EINTR;
1647                 done = unused;
1648         }
1649         else
1650                 write_unlock_irq(&ztv->lock);
1651
1652         /* Yes! we got data! */
1653         max = done->bpl * -done->h;
1654         if (count > max)
1655                 count = max;
1656
1657         /* check if the user gave us enough room to write the data */
1658         if (!access_ok(VERIFY_WRITE, buf, count)) {
1659                 count = -EFAULT;
1660                 goto out;
1661         }
1662
1663         /*
1664          * Now transform/strip the data from YUV to Y-only
1665          * NB. Assume the Y is in the LSB of the YUV data.
1666          */
1667         {
1668         unsigned char* optr = buf;
1669         unsigned char* eptr = buf+count;
1670
1671         /* are we beeing accessed from an old driver? */
1672         if (count == 2*19*2048) {
1673                 /*
1674                  * Extreme HACK, old VBI programs expect 2048 points
1675                  * of data, and we only got 864 orso. Double each
1676                  * datapoint and clear the rest of the line.
1677                  * This way we have appear to have a
1678                  * sample_frequency of 29.5 Mc.
1679                  */
1680                 int x,y;
1681                 unsigned char* iptr = done->memadr+1;
1682                 for (y=done->h; optr<eptr && y<0; y++)
1683                 {
1684                         /* copy to doubled data to userland */
1685                         for (x=0; optr+1<eptr && x<-done->w; x++)
1686                         {
1687                                 unsigned char a = iptr[x*2];
1688                                 __put_user(a, optr++);
1689                                 __put_user(a, optr++);
1690                         }
1691                         /* and clear the rest of the line */
1692                         for (x*=2; optr<eptr && x<done->bpl; x++)
1693                                 __put_user(0, optr++);
1694                         /* next line */
1695                         iptr += done->bpl;
1696                 }
1697         }
1698         else {
1699                 /*
1700                  * Other (probably newer) programs asked
1701                  * us what geometry we are using, and are
1702                  * reading the correct size.
1703                  */
1704                 int x,y;
1705                 unsigned char* iptr = done->memadr+1;
1706                 for (y=done->h; optr<eptr && y<0; y++)
1707                 {
1708                         /* copy to doubled data to userland */
1709                         for (x=0; optr<eptr && x<-done->w; x++)
1710                                 __put_user(iptr[x*2], optr++);
1711                         /* and clear the rest of the line */
1712                         for (;optr<eptr && x<done->bpl; x++)
1713                                 __put_user(0, optr++);
1714                         /* next line */
1715                         iptr += done->bpl;
1716                 }
1717         }
1718
1719         /* API compliance:
1720          * place the framenumber (half fieldnr) in the last long
1721          */
1722         __put_user(done->fieldnr/2, ((ulong*)eptr)[-1]);
1723         }
1724
1725         /* keep the engine running */
1726         done->status = FBUFFER_FREE;
1727         zoran_cap(ztv, 1);
1728
1729         /* tell listeners this buffer just became free */
1730         wake_up_interruptible(&ztv->vbiq);
1731
1732         /* goodbye */
1733 out:
1734         DEBUG(printk(CARD_DEBUG "vbi_read() returns %lu\n",CARD,count));
1735         return count;
1736 }
1737
1738 static
1739 unsigned int vbi_poll(struct video_device *dev, struct file *file, poll_table *wait)
1740 {
1741         struct zoran *ztv = dev->priv;
1742         struct vidinfo* item;
1743         unsigned int mask = 0;
1744
1745         poll_wait(file, &ztv->vbiq, wait);
1746
1747         for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
1748                 if (item->status == FBUFFER_DONE)
1749                 {
1750                         mask |= (POLLIN | POLLRDNORM);
1751                         break;
1752                 }
1753
1754         DEBUG(printk(CARD_DEBUG "vbi_poll()=%x\n",CARD,mask));
1755
1756         return mask;
1757 }
1758
1759 static
1760 int vbi_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
1761 {
1762         struct zoran* ztv = dev->priv;
1763
1764         switch (cmd) {
1765          case VIDIOCGVBIFMT:
1766          {
1767                 struct vbi_format f;
1768                 DEBUG(printk(CARD_DEBUG "VIDIOCGVBIINFO\n",CARD));
1769                 f.sampling_rate = 14750000UL;
1770                 f.samples_per_line = -ztv->readinfo[0].w;
1771                 f.sample_format = VIDEO_PALETTE_RAW;
1772                 f.start[0] = f.start[1] = ztv->readinfo[0].y;
1773                 f.start[1] += 312;
1774                 f.count[0] = f.count[1] = -ztv->readinfo[0].h;
1775                 f.flags = VBI_INTERLACED;
1776                 if (copy_to_user(arg,&f,sizeof(f)))
1777                         return -EFAULT;
1778                 break;
1779          }
1780          case VIDIOCSVBIFMT:
1781          {
1782                 struct vbi_format f;
1783                 int i;
1784                 if (copy_from_user(&f, arg,sizeof(f)))
1785                         return -EFAULT;
1786                 DEBUG(printk(CARD_DEBUG "VIDIOCSVBIINFO(%d,%d,%d,%d,%d,%d,%d,%x)\n",CARD,f.sampling_rate,f.samples_per_line,f.sample_format,f.start[0],f.start[1],f.count[0],f.count[1],f.flags));
1787
1788                 /* lots of parameters are fixed... (PAL) */
1789                 if (f.sampling_rate != 14750000UL ||
1790                     f.samples_per_line > 864 ||
1791                     f.sample_format != VIDEO_PALETTE_RAW ||
1792                     f.start[0] < 0 ||
1793                     f.start[0] != f.start[1]-312 ||
1794                     f.count[0] != f.count[1] ||
1795                     f.start[0]+f.count[0] >= 288 ||
1796                     f.flags != VBI_INTERLACED)
1797                         return -EINVAL;
1798
1799                 write_lock_irq(&ztv->lock);
1800                 ztv->readinfo[0].y = f.start[0];
1801                 ztv->readinfo[0].w = -f.samples_per_line;
1802                 ztv->readinfo[0].h = -f.count[0];
1803                 ztv->readinfo[0].bpl = f.samples_per_line*ztv->readinfo[0].bpp;
1804                 for (i=1; i<ZORAN_VBI_BUFFERS; i++)
1805                         ztv->readinfo[i] = ztv->readinfo[i];
1806                 write_unlock_irq(&ztv->lock);
1807                 break;
1808          }
1809          default:
1810                 return -ENOIOCTLCMD;
1811         }
1812         return 0;
1813 }
1814
1815 static struct video_device vbi_template=
1816 {
1817         .owner          = THIS_MODULE,
1818         .name           = "UNSET",
1819         .type           = VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
1820         .hardware       = VID_HARDWARE_ZR36120,
1821         .open           = vbi_open,
1822         .close          = vbi_close,
1823         .read           = vbi_read,
1824         .write          = zoran_write,
1825         .poll           = vbi_poll,
1826         .ioctl          = vbi_ioctl,
1827         .minor          = -1,
1828 };
1829
1830 /*
1831  *      Scan for a Zoran chip, request the irq and map the io memory
1832  */
1833 static
1834 int __init find_zoran(void)
1835 {
1836         int result;
1837         struct zoran *ztv;
1838         struct pci_dev *dev = NULL;
1839         unsigned char revision;
1840         int zoran_num=0;
1841
1842         while ((dev = pci_find_device(PCI_VENDOR_ID_ZORAN,PCI_DEVICE_ID_ZORAN_36120, dev)))
1843         {
1844                 /* Ok, a ZR36120/ZR36125 found! */
1845                 ztv = &zorans[zoran_num];
1846                 ztv->dev = dev;
1847
1848                 if (pci_enable_device(dev))
1849                         return -EIO;
1850
1851                 pci_read_config_byte(dev, PCI_CLASS_REVISION, &revision);
1852                 printk(KERN_INFO "zoran: Zoran %x (rev %d) ",
1853                         dev->device, revision);
1854                 printk("bus: %d, devfn: %d, irq: %d, ",
1855                         dev->bus->number, dev->devfn, dev->irq);
1856                 printk("memory: 0x%08lx.\n", ztv->zoran_adr);
1857
1858                 ztv->zoran_mem = ioremap(ztv->zoran_adr, 0x1000);
1859                 DEBUG(printk(KERN_DEBUG "zoran: mapped-memory at 0x%p\n",ztv->zoran_mem));
1860
1861                 result = request_irq(dev->irq, zoran_irq,
1862                         SA_SHIRQ|SA_INTERRUPT,"zoran", ztv);
1863                 if (result==-EINVAL)
1864                 {
1865                         iounmap(ztv->zoran_mem);
1866                         printk(KERN_ERR "zoran: Bad irq number or handler\n");
1867                         return -EINVAL;
1868                 }
1869                 if (result==-EBUSY)
1870                         printk(KERN_ERR "zoran: IRQ %d busy, change your PnP config in BIOS\n",dev->irq);
1871                 if (result < 0) {
1872                         iounmap(ztv->zoran_mem);
1873                         return result;
1874                 }
1875                 /* Enable bus-mastering */
1876                 pci_set_master(dev);
1877
1878                 zoran_num++;
1879         }
1880         if(zoran_num)
1881                 printk(KERN_INFO "zoran: %d Zoran card(s) found.\n",zoran_num);
1882         return zoran_num;
1883 }
1884
1885 static
1886 int __init init_zoran(int card)
1887 {
1888         struct zoran *ztv = &zorans[card];
1889         int     i;
1890
1891         /* if the given cardtype valid? */
1892         if (cardtype[card]>=NRTVCARDS) {
1893                 printk(KERN_INFO "invalid cardtype(%d) detected\n",cardtype[card]);
1894                 return -1;
1895         }
1896
1897         /* reset the zoran */
1898         zrand(~ZORAN_PCI_SOFTRESET,ZORAN_PCI);
1899         udelay(10);
1900         zror(ZORAN_PCI_SOFTRESET,ZORAN_PCI);
1901         udelay(10);
1902
1903         /* zoran chip specific details */
1904         ztv->card = tvcards+cardtype[card];     /* point to the selected card */
1905         ztv->norm = 0;                          /* PAL */
1906         ztv->tuner_freq = 0;
1907
1908         /* videocard details */
1909         ztv->swidth = 800;
1910         ztv->sheight = 600;
1911         ztv->depth = 16;
1912
1913         /* State details */
1914         ztv->fbuffer = 0;
1915         ztv->overinfo.kindof = FBUFFER_OVERLAY;
1916         ztv->overinfo.status = FBUFFER_FREE;
1917         ztv->overinfo.x = 0;
1918         ztv->overinfo.y = 0;
1919         ztv->overinfo.w = 768; /* 640 */
1920         ztv->overinfo.h = 576; /* 480 */
1921         ztv->overinfo.format = VIDEO_PALETTE_RGB565;
1922         ztv->overinfo.bpp = palette2fmt[ztv->overinfo.format].bpp;
1923         ztv->overinfo.bpl = ztv->overinfo.bpp*ztv->swidth;
1924         ztv->overinfo.busadr = 0;
1925         ztv->overinfo.memadr = 0;
1926         ztv->overinfo.overlay = 0;
1927         for (i=0; i<ZORAN_MAX_FBUFFERS; i++) {
1928                 ztv->grabinfo[i] = ztv->overinfo;
1929                 ztv->grabinfo[i].kindof = FBUFFER_GRAB;
1930         }
1931         init_waitqueue_head(&ztv->grabq);
1932
1933         /* VBI details */
1934         ztv->readinfo[0] = ztv->overinfo;
1935         ztv->readinfo[0].kindof = FBUFFER_VBI;
1936         ztv->readinfo[0].w = -864;
1937         ztv->readinfo[0].h = -38;
1938         ztv->readinfo[0].format = VIDEO_PALETTE_YUV422;
1939         ztv->readinfo[0].bpp = palette2fmt[ztv->readinfo[0].format].bpp;
1940         ztv->readinfo[0].bpl = 1024*ztv->readinfo[0].bpp;
1941         for (i=1; i<ZORAN_VBI_BUFFERS; i++)
1942                 ztv->readinfo[i] = ztv->readinfo[0];
1943         init_waitqueue_head(&ztv->vbiq);
1944
1945         /* maintenance data */
1946         ztv->have_decoder = 0;
1947         ztv->have_tuner = 0;
1948         ztv->tuner_type = 0;
1949         ztv->running = 0;
1950         ztv->users = 0;
1951         rwlock_init(&ztv->lock);
1952         ztv->workqueue = 0;
1953         ztv->fieldnr = 0;
1954         ztv->lastfieldnr = 0;
1955
1956         if (triton1)
1957                 zrand(~ZORAN_VDC_TRICOM, ZORAN_VDC);
1958
1959         /* external FL determines TOP frame */
1960         zror(ZORAN_VFEC_EXTFL, ZORAN_VFEC);
1961
1962         /* set HSpol */
1963         if (ztv->card->hsync_pos)
1964                 zrwrite(ZORAN_VFEH_HSPOL, ZORAN_VFEH);
1965         /* set VSpol */
1966         if (ztv->card->vsync_pos)
1967                 zrwrite(ZORAN_VFEV_VSPOL, ZORAN_VFEV);
1968
1969         /* Set the proper General Purpuse register bits */
1970         /* implicit: no softreset, 0 waitstates */
1971         zrwrite(ZORAN_PCI_SOFTRESET|(ztv->card->gpdir<<0),ZORAN_PCI);
1972         /* implicit: 3 duration and recovery PCI clocks on guest 0-3 */
1973         zrwrite(ztv->card->gpval<<24,ZORAN_GUEST);
1974
1975         /* clear interrupt status */
1976         zrwrite(~0, ZORAN_ISR);
1977
1978         /*
1979          * i2c template
1980          */
1981         ztv->i2c = zoran_i2c_bus_template;
1982         sprintf(ztv->i2c.name,"zoran-%d",card);
1983         ztv->i2c.data = ztv;
1984
1985         /*
1986          * Now add the template and register the device unit
1987          */
1988         ztv->video_dev = zr36120_template;
1989         strcpy(ztv->video_dev.name, ztv->i2c.name);
1990         ztv->video_dev.priv = ztv;
1991         if (video_register_device(&ztv->video_dev, VFL_TYPE_GRABBER, video_nr) < 0)
1992                 return -1;
1993
1994         ztv->vbi_dev = vbi_template;
1995         strcpy(ztv->vbi_dev.name, ztv->i2c.name);
1996         ztv->vbi_dev.priv = ztv;
1997         if (video_register_device(&ztv->vbi_dev, VFL_TYPE_VBI, vbi_nr) < 0) {
1998                 video_unregister_device(&ztv->video_dev);
1999                 return -1;
2000         }
2001         i2c_register_bus(&ztv->i2c);
2002
2003         /* set interrupt mask - the PIN enable will be set later */
2004         zrwrite(ZORAN_ICR_GIRQ0|ZORAN_ICR_GIRQ1|ZORAN_ICR_CODE, ZORAN_ICR);
2005
2006         printk(KERN_INFO "%s: installed %s\n",ztv->i2c.name,ztv->card->name);
2007         return 0;
2008 }
2009
2010 static
2011 void release_zoran(int max)
2012 {
2013         struct zoran *ztv;
2014         int i;
2015
2016         for (i=0;i<max; i++)
2017         {
2018                 ztv = &zorans[i];
2019
2020                 /* turn off all capturing, DMA and IRQs */
2021                 /* reset the zoran */
2022                 zrand(~ZORAN_PCI_SOFTRESET,ZORAN_PCI);
2023                 udelay(10);
2024                 zror(ZORAN_PCI_SOFTRESET,ZORAN_PCI);
2025                 udelay(10);
2026
2027                 /* first disable interrupts before unmapping the memory! */
2028                 zrwrite(0, ZORAN_ICR);
2029                 zrwrite(0xffffffffUL,ZORAN_ISR);
2030
2031                 /* free it */
2032                 free_irq(ztv->dev->irq,ztv);
2033
2034                 /* unregister i2c_bus */
2035                 i2c_unregister_bus((&ztv->i2c));
2036
2037                 /* unmap and free memory */
2038                 if (ztv->zoran_mem)
2039                         iounmap(ztv->zoran_mem);
2040
2041                 video_unregister_device(&ztv->video_dev);
2042                 video_unregister_device(&ztv->vbi_dev);
2043         }
2044 }
2045
2046 void __exit zr36120_exit(void)
2047 {
2048         release_zoran(zoran_cards);
2049 }
2050
2051 int __init zr36120_init(void)
2052 {
2053         int     card;
2054
2055         handle_chipset();
2056         zoran_cards = find_zoran();
2057         if (zoran_cards<0)
2058                 /* no cards found, no need for a driver */
2059                 return -EIO;
2060
2061         /* initialize Zorans */
2062         for (card=0; card<zoran_cards; card++) {
2063                 if (init_zoran(card)<0) {
2064                         /* only release the zorans we have registered */
2065                         release_zoran(card);
2066                         return -EIO;
2067                 }
2068         }
2069         return 0;
2070 }
2071
2072 module_init(zr36120_init);
2073 module_exit(zr36120_exit);