Pull sn-features into release branch
[linux-2.6] / 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         bfree(ztv->fbuffer, ZORAN_MAX_FBUFSIZE);
824         ztv->fbuffer = 0;
825         kfree(ztv->overinfo.overlay);
826         ztv->overinfo.overlay = 0;
827
828 }
829
830 /*
831  * This read function could be used reentrant in a SMP situation.
832  *
833  * This is made possible by the spinlock which is kept till we
834  * found and marked a buffer for our own use. The lock must
835  * be released as soon as possible to prevent lock contention.
836  */
837 static
838 long zoran_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
839 {
840         struct zoran *ztv = (struct zoran*)dev;
841         unsigned long max;
842         struct vidinfo* unused = 0;
843         struct vidinfo* done = 0;
844
845         DEBUG(printk(CARD_DEBUG "zoran_read(%p,%ld,%d)\n",CARD,buf,count,nonblock));
846
847         /* find ourself a free or completed buffer */
848         for (;;) {
849                 struct vidinfo* item;
850
851                 write_lock_irq(&ztv->lock);
852                 for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
853                 {
854                         if (!unused && item->status == FBUFFER_FREE)
855                                 unused = item;
856                         if (!done && item->status == FBUFFER_DONE)
857                                 done = item;
858                 }
859                 if (done || unused)
860                         break;
861
862                 /* no more free buffers, wait for them. */
863                 write_unlock_irq(&ztv->lock);
864                 if (nonblock)
865                         return -EWOULDBLOCK;
866                 interruptible_sleep_on(&ztv->grabq);
867                 if (signal_pending(current))
868                         return -EINTR;
869         }
870
871         /* Do we have 'ready' data? */
872         if (!done) {
873                 /* no? than this will take a while... */
874                 if (nonblock) {
875                         write_unlock_irq(&ztv->lock);
876                         return -EWOULDBLOCK;
877                 }
878
879                 /* mark the unused buffer as wanted */
880                 unused->status = FBUFFER_BUSY;
881                 unused->w = 320;
882                 unused->h = 240;
883                 unused->format = VIDEO_PALETTE_RGB24;
884                 unused->bpp = palette2fmt[unused->format].bpp;
885                 unused->bpl = unused->w * unused->bpp;
886                 unused->next = 0;
887                 { /* add to tail of queue */
888                   struct vidinfo* oldframe = ztv->workqueue;
889                   if (!oldframe) ztv->workqueue = unused;
890                   else {
891                     while (oldframe->next) oldframe = oldframe->next;
892                     oldframe->next = unused;
893                   }
894                 }
895                 write_unlock_irq(&ztv->lock);
896
897                 /* tell the state machine we want it filled /NOW/ */
898                 zoran_cap(ztv, 1);
899
900                 /* wait till this buffer gets grabbed */
901                 wait_event_interruptible(ztv->grabq,
902                                 (unused->status != FBUFFER_BUSY));
903                 /* see if a signal did it */
904                 if (signal_pending(current))
905                         return -EINTR;
906                 done = unused;
907         }
908         else
909                 write_unlock_irq(&ztv->lock);
910
911         /* Yes! we got data! */
912         max = done->bpl * done->h;
913         if (count > max)
914                 count = max;
915         if (copy_to_user((void*)buf, done->memadr, count))
916                 count = -EFAULT;
917
918         /* keep the engine running */
919         done->status = FBUFFER_FREE;
920 //      zoran_cap(ztv,1);
921
922         /* tell listeners this buffer became free */
923         wake_up_interruptible(&ztv->grabq);
924
925         /* goodbye */
926         DEBUG(printk(CARD_DEBUG "zoran_read() returns %lu\n",CARD,count));
927         return count;
928 }
929
930 static
931 long zoran_write(struct video_device* dev, const char* buf, unsigned long count, int nonblock)
932 {
933         struct zoran *ztv = (struct zoran *)dev;
934         UNUSED(ztv); UNUSED(dev); UNUSED(buf); UNUSED(count); UNUSED(nonblock);
935         DEBUG(printk(CARD_DEBUG "zoran_write\n",CARD));
936         return -EINVAL;
937 }
938
939 static
940 unsigned int zoran_poll(struct video_device *dev, struct file *file, poll_table *wait)
941 {
942         struct zoran *ztv = (struct zoran *)dev;
943         struct vidinfo* item;
944         unsigned int mask = 0;
945
946         poll_wait(file, &ztv->grabq, wait);
947
948         for (item=ztv->grabinfo; item!=ztv->grabinfo+ZORAN_MAX_FBUFFERS; item++)
949                 if (item->status == FBUFFER_DONE)
950                 {
951                         mask |= (POLLIN | POLLRDNORM);
952                         break;
953                 }
954
955         DEBUG(printk(CARD_DEBUG "zoran_poll()=%x\n",CARD,mask));
956
957         return mask;
958 }
959
960 /* append a new clipregion to the vector of video_clips */
961 static
962 void new_clip(struct video_window* vw, struct video_clip* vcp, int x, int y, int w, int h)
963 {
964         vcp[vw->clipcount].x = x;
965         vcp[vw->clipcount].y = y;
966         vcp[vw->clipcount].width = w;
967         vcp[vw->clipcount].height = h;
968         vw->clipcount++;
969 }
970
971 static
972 int zoran_ioctl(struct video_device* dev, unsigned int cmd, void *arg)
973 {
974         struct zoran* ztv = (struct zoran*)dev;
975
976         switch (cmd) {
977          case VIDIOCGCAP:
978          {
979                 struct video_capability c;
980                 DEBUG(printk(CARD_DEBUG "VIDIOCGCAP\n",CARD));
981
982                 strcpy(c.name,ztv->video_dev.name);
983                 c.type = VID_TYPE_CAPTURE|
984                          VID_TYPE_OVERLAY|
985                          VID_TYPE_CLIPPING|
986                          VID_TYPE_FRAMERAM|
987                          VID_TYPE_SCALES;
988                 if (ztv->have_tuner)
989                         c.type |= VID_TYPE_TUNER;
990                 if (ztv->have_decoder) {
991                         c.channels = ztv->card->video_inputs;
992                         c.audios = ztv->card->audio_inputs;
993                 } else
994                         /* no decoder -> no channels */
995                         c.channels = c.audios = 0;
996                 c.maxwidth = 768;
997                 c.maxheight = 576;
998                 c.minwidth = 32;
999                 c.minheight = 32;
1000                 if (copy_to_user(arg,&c,sizeof(c)))
1001                         return -EFAULT;
1002                 break;
1003          }
1004
1005          case VIDIOCGCHAN:
1006          {
1007                 struct video_channel v;
1008                 int mux;
1009                 if (copy_from_user(&v, arg,sizeof(v)))
1010                         return -EFAULT;
1011                 DEBUG(printk(CARD_DEBUG "VIDIOCGCHAN(%d)\n",CARD,v.channel));
1012                 v.flags=VIDEO_VC_AUDIO
1013 #ifdef VIDEO_VC_NORM
1014                         |VIDEO_VC_NORM
1015 #endif
1016                         ;
1017                 v.tuners=0;
1018                 v.type=VIDEO_TYPE_CAMERA;
1019 #ifdef I_EXPECT_POSSIBLE_NORMS_IN_THE_API
1020                 v.norm=VIDEO_MODE_PAL|
1021                        VIDEO_MODE_NTSC|
1022                        VIDEO_MODE_SECAM;
1023 #else
1024                 v.norm=VIDEO_MODE_PAL;
1025 #endif
1026                 /* too many inputs? no decoder -> no channels */
1027                 if (!ztv->have_decoder || v.channel < 0 ||  v.channel >= ztv->card->video_inputs)
1028                         return -EINVAL;
1029
1030                 /* now determine the name of the channel */
1031                 mux = ztv->card->video_mux[v.channel];
1032                 if (mux & IS_TUNER) {
1033                         /* lets assume only one tuner, yes? */
1034                         strcpy(v.name,"Television");
1035                         v.type = VIDEO_TYPE_TV;
1036                         if (ztv->have_tuner) {
1037                                 v.flags |= VIDEO_VC_TUNER;
1038                                 v.tuners = 1;
1039                         }
1040                 }
1041                 else if (mux & IS_SVHS)
1042                         sprintf(v.name,"S-Video-%d",v.channel);
1043                 else
1044                         sprintf(v.name,"CVBS-%d",v.channel);
1045
1046                 if (copy_to_user(arg,&v,sizeof(v)))
1047                         return -EFAULT;
1048                 break;
1049          }
1050          case VIDIOCSCHAN:
1051          {      /* set video channel */
1052                 struct video_channel v;
1053                 if (copy_from_user(&v, arg,sizeof(v)))
1054                         return -EFAULT;
1055                 DEBUG(printk(CARD_DEBUG "VIDIOCSCHAN(%d,%d)\n",CARD,v.channel,v.norm));
1056
1057                 /* too many inputs? no decoder -> no channels */
1058                 if (!ztv->have_decoder || v.channel >= ztv->card->video_inputs || v.channel < 0)
1059                         return -EINVAL;
1060
1061                 if (v.norm != VIDEO_MODE_PAL &&
1062                     v.norm != VIDEO_MODE_NTSC &&
1063                     v.norm != VIDEO_MODE_SECAM &&
1064                     v.norm != VIDEO_MODE_AUTO)
1065                         return -EOPNOTSUPP;
1066
1067                 /* make it happen, nr1! */
1068                 return zoran_muxsel(ztv,v.channel,v.norm);
1069          }
1070
1071          case VIDIOCGTUNER:
1072          {
1073                 struct video_tuner v;
1074                 if (copy_from_user(&v, arg,sizeof(v)))
1075                         return -EFAULT;
1076                 DEBUG(printk(CARD_DEBUG "VIDIOCGTUNER(%d)\n",CARD,v.tuner));
1077
1078                 /* Only no or one tuner for now */
1079                 if (!ztv->have_tuner || v.tuner)
1080                         return -EINVAL;
1081
1082                 strcpy(v.name,"Television");
1083                 v.rangelow  = 0;
1084                 v.rangehigh = ~0;
1085                 v.flags     = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1086                 v.mode      = ztv->norm;
1087                 v.signal    = 0xFFFF; /* unknown */
1088
1089                 if (copy_to_user(arg,&v,sizeof(v)))
1090                         return -EFAULT;
1091                 break;
1092          }
1093          case VIDIOCSTUNER:
1094          {
1095                 struct video_tuner v;
1096                 if (copy_from_user(&v, arg, sizeof(v)))
1097                         return -EFAULT;
1098                 DEBUG(printk(CARD_DEBUG "VIDIOCSTUNER(%d,%d)\n",CARD,v.tuner,v.mode));
1099
1100                 /* Only no or one tuner for now */
1101                 if (!ztv->have_tuner || v.tuner)
1102                         return -EINVAL;
1103
1104                 /* and it only has certain valid modes */
1105                 if( v.mode != VIDEO_MODE_PAL &&
1106                     v.mode != VIDEO_MODE_NTSC &&
1107                     v.mode != VIDEO_MODE_SECAM)
1108                         return -EOPNOTSUPP;
1109
1110                 /* engage! */
1111                 return zoran_muxsel(ztv,v.tuner,v.mode);
1112          }
1113
1114          case VIDIOCGPICT:
1115          {
1116                 struct video_picture p = ztv->picture;
1117                 DEBUG(printk(CARD_DEBUG "VIDIOCGPICT\n",CARD));
1118                 p.depth = ztv->depth;
1119                 switch (p.depth) {
1120                  case  8: p.palette=VIDEO_PALETTE_YUV422;
1121                           break;
1122                  case 15: p.palette=VIDEO_PALETTE_RGB555;
1123                           break;
1124                  case 16: p.palette=VIDEO_PALETTE_RGB565;
1125                           break;
1126                  case 24: p.palette=VIDEO_PALETTE_RGB24;
1127                           break;
1128                  case 32: p.palette=VIDEO_PALETTE_RGB32;
1129                           break;
1130                 }
1131                 if (copy_to_user(arg, &p, sizeof(p)))
1132                         return -EFAULT;
1133                 break;
1134          }
1135          case VIDIOCSPICT:
1136          {
1137                 struct video_picture p;
1138                 if (copy_from_user(&p, arg,sizeof(p)))
1139                         return -EFAULT;
1140                 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));
1141
1142                 /* depth must match with framebuffer */
1143                 if (p.depth != ztv->depth)
1144                         return -EINVAL;
1145
1146                 /* check if palette matches this bpp */
1147                 if (p.palette>NRPALETTES ||
1148                     palette2fmt[p.palette].bpp != ztv->overinfo.bpp)
1149                         return -EINVAL;
1150
1151                 write_lock_irq(&ztv->lock);
1152                 ztv->overinfo.format = p.palette;
1153                 ztv->picture = p;
1154                 write_unlock_irq(&ztv->lock);
1155
1156                 /* tell the decoder */
1157                 i2c_control_device(&ztv->i2c, I2C_DRIVERID_VIDEODECODER, DECODER_SET_PICTURE, &p);
1158                 break;
1159          }
1160
1161          case VIDIOCGWIN:
1162          {
1163                 struct video_window vw;
1164                 DEBUG(printk(CARD_DEBUG "VIDIOCGWIN\n",CARD));
1165                 read_lock(&ztv->lock);
1166                 vw.x      = ztv->overinfo.x;
1167                 vw.y      = ztv->overinfo.y;
1168                 vw.width  = ztv->overinfo.w;
1169                 vw.height = ztv->overinfo.h;
1170                 vw.chromakey= 0;
1171                 vw.flags  = 0;
1172                 if (ztv->vidInterlace)
1173                         vw.flags|=VIDEO_WINDOW_INTERLACE;
1174                 read_unlock(&ztv->lock);
1175                 if (copy_to_user(arg,&vw,sizeof(vw)))
1176                         return -EFAULT;
1177                 break;
1178          }
1179          case VIDIOCSWIN:
1180          {
1181                 struct video_window vw;
1182                 struct video_clip *vcp;
1183                 int on;
1184                 if (copy_from_user(&vw,arg,sizeof(vw)))
1185                         return -EFAULT;
1186                 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));
1187
1188                 if (vw.flags)
1189                         return -EINVAL;
1190
1191                 if (vw.clipcount <0 || vw.clipcount>256)
1192                         return -EDOM;   /* Too many! */
1193
1194                 /*
1195                  *      Do any clips.
1196                  */
1197                 vcp = vmalloc(sizeof(struct video_clip)*(vw.clipcount+4));
1198                 if (vcp==NULL)
1199                         return -ENOMEM;
1200                 if (vw.clipcount && copy_from_user(vcp,vw.clips,sizeof(struct video_clip)*vw.clipcount)) {
1201                         vfree(vcp);
1202                         return -EFAULT;
1203                 }
1204
1205                 on = ztv->running;
1206                 if (on)
1207                         zoran_cap(ztv, 0);
1208
1209                 /*
1210                  * strange, it seems xawtv sometimes calls us with 0
1211                  * width and/or height. Ignore these values
1212                  */
1213                 if (vw.x == 0)
1214                         vw.x = ztv->overinfo.x;
1215                 if (vw.y == 0)
1216                         vw.y = ztv->overinfo.y;
1217
1218                 /* by now we are committed to the new data... */
1219                 write_lock_irq(&ztv->lock);
1220                 ztv->overinfo.x = vw.x;
1221                 ztv->overinfo.y = vw.y;
1222                 ztv->overinfo.w = vw.width;
1223                 ztv->overinfo.h = vw.height;
1224                 write_unlock_irq(&ztv->lock);
1225
1226                 /*
1227                  *      Impose display clips
1228                  */
1229                 if (vw.x+vw.width > ztv->swidth)
1230                         new_clip(&vw, vcp, ztv->swidth-vw.x, 0, vw.width-1, vw.height-1);
1231                 if (vw.y+vw.height > ztv->sheight)
1232                         new_clip(&vw, vcp, 0, ztv->sheight-vw.y, vw.width-1, vw.height-1);
1233
1234                 /* built the requested clipping zones */
1235                 zoran_set_geo(ztv, &ztv->overinfo);
1236                 zoran_built_overlay(ztv, vw.clipcount, vcp);
1237                 vfree(vcp);
1238
1239                 /* if we were on, restart the video engine */
1240                 if (on)
1241                         zoran_cap(ztv, 1);
1242                 break;
1243          }
1244
1245          case VIDIOCCAPTURE:
1246          {
1247                 int v;
1248                 if (get_user(v, (int *)arg))
1249                         return -EFAULT;
1250                 DEBUG(printk(CARD_DEBUG "VIDIOCCAPTURE(%d)\n",CARD,v));
1251
1252                 if (v==0) {
1253                         clear_bit(STATE_OVERLAY, &ztv->state);
1254                         zoran_cap(ztv, 1);
1255                 }
1256                 else {
1257                         /* is VIDIOCSFBUF, VIDIOCSWIN done? */
1258                         if (ztv->overinfo.busadr==0 || ztv->overinfo.w==0 || ztv->overinfo.h==0)
1259                                 return -EINVAL;
1260
1261                         set_bit(STATE_OVERLAY, &ztv->state);
1262                         zoran_cap(ztv, 1);
1263                 }
1264                 break;
1265          }
1266
1267          case VIDIOCGFBUF:
1268          {
1269                 struct video_buffer v;
1270                 DEBUG(printk(CARD_DEBUG "VIDIOCGFBUF\n",CARD));
1271                 read_lock(&ztv->lock);
1272                 v.base   = (void *)ztv->overinfo.busadr;
1273                 v.height = ztv->sheight;
1274                 v.width  = ztv->swidth;
1275                 v.depth  = ztv->depth;
1276                 v.bytesperline = ztv->overinfo.bpl;
1277                 read_unlock(&ztv->lock);
1278                 if(copy_to_user(arg, &v,sizeof(v)))
1279                         return -EFAULT;
1280                 break;
1281          }
1282          case VIDIOCSFBUF:
1283          {
1284                 struct video_buffer v;
1285                 if(!capable(CAP_SYS_ADMIN))
1286                         return -EPERM;
1287                 if (copy_from_user(&v, arg,sizeof(v)))
1288                         return -EFAULT;
1289                 DEBUG(printk(CARD_DEBUG "VIDIOCSFBUF(%p,%d,%d,%d,%d)\n",CARD,v.base, v.width,v.height,v.depth,v.bytesperline));
1290
1291                 if (v.depth!=15 && v.depth!=16 && v.depth!=24 && v.depth!=32)
1292                         return -EINVAL;
1293                 if (v.bytesperline<1)
1294                         return -EINVAL;
1295                 if (ztv->running)
1296                         return -EBUSY;
1297                 write_lock_irq(&ztv->lock);
1298                 ztv->overinfo.busadr  = (ulong)v.base;
1299                 ztv->sheight      = v.height;
1300                 ztv->swidth       = v.width;
1301                 ztv->depth        = v.depth;            /* bits per pixel */
1302                 ztv->overinfo.bpp = ((v.depth+1)&0x38)/8;/* bytes per pixel */
1303                 ztv->overinfo.bpl = v.bytesperline;     /* bytes per line */
1304                 write_unlock_irq(&ztv->lock);
1305                 break;
1306          }
1307
1308          case VIDIOCKEY:
1309          {
1310                 /* Will be handled higher up .. */
1311                 break;
1312          }
1313
1314          case VIDIOCSYNC:
1315          {
1316                 int i;
1317                 if (get_user(i, (int *) arg))
1318                         return -EFAULT;
1319                 DEBUG(printk(CARD_DEBUG "VIDEOCSYNC(%d)\n",CARD,i));
1320                 if (i<0 || i>ZORAN_MAX_FBUFFERS)
1321                         return -EINVAL;
1322                 switch (ztv->grabinfo[i].status) {
1323                  case FBUFFER_FREE:
1324                         return -EINVAL;
1325                  case FBUFFER_BUSY:
1326                         /* wait till this buffer gets grabbed */
1327                         wait_event_interruptible(ztv->grabq,
1328                                         (ztv->grabinfo[i].status != FBUFFER_BUSY));
1329                         /* see if a signal did it */
1330                         if (signal_pending(current))
1331                                 return -EINTR;
1332                         /* don't fall through; a DONE buffer is not UNUSED */
1333                         break;
1334                  case FBUFFER_DONE:
1335                         ztv->grabinfo[i].status = FBUFFER_FREE;
1336                         /* tell ppl we have a spare buffer */
1337                         wake_up_interruptible(&ztv->grabq);
1338                         break;
1339                 }
1340                 DEBUG(printk(CARD_DEBUG "VIDEOCSYNC(%d) returns\n",CARD,i));
1341                 break;
1342          }
1343
1344          case VIDIOCMCAPTURE:
1345          {
1346                 struct video_mmap vm;
1347                 struct vidinfo* frame;
1348                 if (copy_from_user(&vm,arg,sizeof(vm)))
1349                         return -EFAULT;
1350                 DEBUG(printk(CARD_DEBUG "VIDIOCMCAPTURE(%d,(%d,%d),%d)\n",CARD,vm.frame,vm.width,vm.height,vm.format));
1351                 if (vm.frame<0 || vm.frame>ZORAN_MAX_FBUFFERS ||
1352                     vm.width<32 || vm.width>768 ||
1353                     vm.height<32 || vm.height>576 ||
1354                     vm.format>NRPALETTES ||
1355                     palette2fmt[vm.format].mode == 0)
1356                         return -EINVAL;
1357
1358                 /* we are allowed to take over UNUSED and DONE buffers */
1359                 frame = &ztv->grabinfo[vm.frame];
1360                 if (frame->status == FBUFFER_BUSY)
1361                         return -EBUSY;
1362
1363                 /* setup the other parameters if they are given */
1364                 write_lock_irq(&ztv->lock);
1365                 frame->w = vm.width;
1366                 frame->h = vm.height;
1367                 frame->format = vm.format;
1368                 frame->bpp = palette2fmt[frame->format].bpp;
1369                 frame->bpl = frame->w*frame->bpp;
1370                 frame->status = FBUFFER_BUSY;
1371                 frame->next = 0;
1372                 { /* add to tail of queue */
1373                   struct vidinfo* oldframe = ztv->workqueue;
1374                   if (!oldframe) ztv->workqueue = frame;
1375                   else {
1376                     while (oldframe->next) oldframe = oldframe->next;
1377                     oldframe->next = frame;
1378                   }
1379                 }
1380                 write_unlock_irq(&ztv->lock);
1381                 zoran_cap(ztv, 1);
1382                 break;
1383          }
1384
1385          case VIDIOCGMBUF:
1386          {
1387                 struct video_mbuf mb;
1388                 int i;
1389                 DEBUG(printk(CARD_DEBUG "VIDIOCGMBUF\n",CARD));
1390                 mb.size = ZORAN_MAX_FBUFSIZE;
1391                 mb.frames = ZORAN_MAX_FBUFFERS;
1392                 for (i=0; i<ZORAN_MAX_FBUFFERS; i++)
1393                         mb.offsets[i] = i*ZORAN_MAX_FBUFFER;
1394                 if(copy_to_user(arg, &mb,sizeof(mb)))
1395                         return -EFAULT;
1396                 break;
1397          }
1398
1399          case VIDIOCGUNIT:
1400          {
1401                 struct video_unit vu;
1402                 DEBUG(printk(CARD_DEBUG "VIDIOCGUNIT\n",CARD));
1403                 vu.video = ztv->video_dev.minor;
1404                 vu.vbi = ztv->vbi_dev.minor;
1405                 vu.radio = VIDEO_NO_UNIT;
1406                 vu.audio = VIDEO_NO_UNIT;
1407                 vu.teletext = VIDEO_NO_UNIT;
1408                 if(copy_to_user(arg, &vu,sizeof(vu)))
1409                         return -EFAULT;
1410                 break;
1411          }
1412
1413          case VIDIOCGFREQ:
1414          {
1415                 unsigned long v = ztv->tuner_freq;
1416                 if (copy_to_user(arg,&v,sizeof(v)))
1417                         return -EFAULT;
1418                 DEBUG(printk(CARD_DEBUG "VIDIOCGFREQ\n",CARD));
1419                 break;
1420          }
1421          case VIDIOCSFREQ:
1422          {
1423                 unsigned long v;
1424                 if (copy_from_user(&v, arg, sizeof(v)))
1425                         return -EFAULT;
1426                 DEBUG(printk(CARD_DEBUG "VIDIOCSFREQ\n",CARD));
1427
1428                 if (ztv->have_tuner) {
1429                         int fixme = v;
1430                         if (i2c_control_device(&(ztv->i2c), I2C_DRIVERID_TUNER, TUNER_SET_TVFREQ, &fixme) < 0)
1431                                 return -EAGAIN;
1432                 }
1433                 ztv->tuner_freq = v;
1434                 break;
1435          }
1436
1437          /* Why isn't this in the API?
1438           * And why doesn't it take a buffer number?
1439          case BTTV_FIELDNR: 
1440          {
1441                 unsigned long v = ztv->lastfieldnr;
1442                 if (copy_to_user(arg,&v,sizeof(v)))
1443                         return -EFAULT;
1444                 DEBUG(printk(CARD_DEBUG "BTTV_FIELDNR\n",CARD));
1445                 break;
1446          }
1447          */
1448
1449          default:
1450                 return -ENOIOCTLCMD;
1451         }
1452         return 0;
1453 }
1454
1455 static
1456 int zoran_mmap(struct vm_area_struct *vma, struct video_device* dev, const char* adr, unsigned long size)
1457 {
1458         struct zoran* ztv = (struct zoran*)dev;
1459         unsigned long start = (unsigned long)adr;
1460         unsigned long pos;
1461
1462         DEBUG(printk(CARD_DEBUG "zoran_mmap(0x%p,%ld)\n",CARD,adr,size));
1463
1464         /* sanity checks */
1465         if (size > ZORAN_MAX_FBUFSIZE || !ztv->fbuffer)
1466                 return -EINVAL;
1467
1468         /* start mapping the whole shabang to user memory */
1469         pos = (unsigned long)ztv->fbuffer;
1470         while (size>0) {
1471                 unsigned long pfn = virt_to_phys((void*)pos) >> PAGE_SHIFT;
1472                 if (remap_pfn_range(vma, start, pfn, PAGE_SIZE, PAGE_SHARED))
1473                         return -EAGAIN;
1474                 start += PAGE_SIZE;
1475                 pos += PAGE_SIZE;
1476                 size -= PAGE_SIZE;
1477         }
1478         return 0;
1479 }
1480
1481 static struct video_device zr36120_template=
1482 {
1483         .owner          = THIS_MODULE,
1484         .name           = "UNSET",
1485         .type           = VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY,
1486         .hardware       = VID_HARDWARE_ZR36120,
1487         .open           = zoran_open,
1488         .close          = zoran_close,
1489         .read           = zoran_read,
1490         .write          = zoran_write,
1491         .poll           = zoran_poll,
1492         .ioctl          = zoran_ioctl,
1493         .mmap           = zoran_mmap,
1494         .minor          = -1,
1495 };
1496
1497 static
1498 int vbi_open(struct video_device *dev, int flags)
1499 {
1500         struct zoran *ztv = dev->priv;
1501         struct vidinfo* item;
1502
1503         DEBUG(printk(CARD_DEBUG "vbi_open(dev,%d)\n",CARD,flags));
1504
1505         /*
1506          * During VBI device open, we continiously grab VBI-like
1507          * data in the vbi buffer when we have nothing to do.
1508          * Only when there is an explicit request for VBI data
1509          * (read call) we /force/ a read.
1510          */
1511
1512         /* allocate buffers */
1513         for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
1514         {
1515                 item->status = FBUFFER_FREE;
1516
1517                 /* alloc */
1518                 if (!item->memadr) {
1519                         item->memadr = bmalloc(ZORAN_VBI_BUFSIZE);
1520                         if (!item->memadr) {
1521                                 /* could not get a buffer, bail out */
1522                                 while (item != ztv->readinfo) {
1523                                         item--;
1524                                         bfree(item->memadr, ZORAN_VBI_BUFSIZE);
1525                                         item->memadr = 0;
1526                                         item->busadr = 0;
1527                                 }
1528                                 return -ENOBUFS;
1529                         }
1530                 }
1531
1532                 /* determine the DMAable address */
1533                 item->busadr = virt_to_bus(item->memadr);
1534         }
1535
1536         /* do the common part of all open's */
1537         zoran_common_open(ztv, flags);
1538
1539         set_bit(STATE_VBI, &ztv->state);
1540         /* start read-ahead */
1541         zoran_cap(ztv, 1);
1542
1543         return 0;
1544 }
1545
1546 static
1547 void vbi_close(struct video_device *dev)
1548 {
1549         struct zoran *ztv = dev->priv;
1550         struct vidinfo* item;
1551
1552         DEBUG(printk(CARD_DEBUG "vbi_close(dev)\n",CARD));
1553
1554         /* driver specific closure */
1555         clear_bit(STATE_VBI, &ztv->state);
1556
1557         zoran_common_close(ztv);
1558
1559         /*
1560          *      This is sucky but right now I can't find a good way to
1561          *      be sure its safe to free the buffer. We wait 5-6 fields
1562          *      which is more than sufficient to be sure.
1563          */
1564         msleep(100);                    /* Wait 1/10th of a second */
1565
1566         for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
1567         {
1568                 if (item->memadr)
1569                         bfree(item->memadr, ZORAN_VBI_BUFSIZE);
1570                 item->memadr = 0;
1571         }
1572
1573 }
1574
1575 /*
1576  * This read function could be used reentrant in a SMP situation.
1577  *
1578  * This is made possible by the spinlock which is kept till we
1579  * found and marked a buffer for our own use. The lock must
1580  * be released as soon as possible to prevent lock contention.
1581  */
1582 static
1583 long vbi_read(struct video_device* dev, char* buf, unsigned long count, int nonblock)
1584 {
1585         struct zoran *ztv = dev->priv;
1586         unsigned long max;
1587         struct vidinfo* unused = 0;
1588         struct vidinfo* done = 0;
1589
1590         DEBUG(printk(CARD_DEBUG "vbi_read(0x%p,%ld,%d)\n",CARD,buf,count,nonblock));
1591
1592         /* find ourself a free or completed buffer */
1593         for (;;) {
1594                 struct vidinfo* item;
1595
1596                 write_lock_irq(&ztv->lock);
1597                 for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++) {
1598                         if (!unused && item->status == FBUFFER_FREE)
1599                                 unused = item;
1600                         if (!done && item->status == FBUFFER_DONE)
1601                                 done = item;
1602                 }
1603                 if (done || unused)
1604                         break;
1605
1606                 /* no more free buffers, wait for them. */
1607                 write_unlock_irq(&ztv->lock);
1608                 if (nonblock)
1609                         return -EWOULDBLOCK;
1610                 interruptible_sleep_on(&ztv->vbiq);
1611                 if (signal_pending(current))
1612                         return -EINTR;
1613         }
1614
1615         /* Do we have 'ready' data? */
1616         if (!done) {
1617                 /* no? than this will take a while... */
1618                 if (nonblock) {
1619                         write_unlock_irq(&ztv->lock);
1620                         return -EWOULDBLOCK;
1621                 }
1622                 
1623                 /* mark the unused buffer as wanted */
1624                 unused->status = FBUFFER_BUSY;
1625                 unused->next = 0;
1626                 { /* add to tail of queue */
1627                   struct vidinfo* oldframe = ztv->workqueue;
1628                   if (!oldframe) ztv->workqueue = unused;
1629                   else {
1630                     while (oldframe->next) oldframe = oldframe->next;
1631                     oldframe->next = unused;
1632                   }
1633                 }
1634                 write_unlock_irq(&ztv->lock);
1635
1636                 /* tell the state machine we want it filled /NOW/ */
1637                 zoran_cap(ztv, 1);
1638
1639                 /* wait till this buffer gets grabbed */
1640                 wait_event_interruptible(ztv->vbiq,
1641                                 (unused->status != FBUFFER_BUSY));
1642                 /* see if a signal did it */
1643                 if (signal_pending(current))
1644                         return -EINTR;
1645                 done = unused;
1646         }
1647         else
1648                 write_unlock_irq(&ztv->lock);
1649
1650         /* Yes! we got data! */
1651         max = done->bpl * -done->h;
1652         if (count > max)
1653                 count = max;
1654
1655         /* check if the user gave us enough room to write the data */
1656         if (!access_ok(VERIFY_WRITE, buf, count)) {
1657                 count = -EFAULT;
1658                 goto out;
1659         }
1660
1661         /*
1662          * Now transform/strip the data from YUV to Y-only
1663          * NB. Assume the Y is in the LSB of the YUV data.
1664          */
1665         {
1666         unsigned char* optr = buf;
1667         unsigned char* eptr = buf+count;
1668
1669         /* are we beeing accessed from an old driver? */
1670         if (count == 2*19*2048) {
1671                 /*
1672                  * Extreme HACK, old VBI programs expect 2048 points
1673                  * of data, and we only got 864 orso. Double each 
1674                  * datapoint and clear the rest of the line.
1675                  * This way we have appear to have a
1676                  * sample_frequency of 29.5 Mc.
1677                  */
1678                 int x,y;
1679                 unsigned char* iptr = done->memadr+1;
1680                 for (y=done->h; optr<eptr && y<0; y++)
1681                 {
1682                         /* copy to doubled data to userland */
1683                         for (x=0; optr+1<eptr && x<-done->w; x++)
1684                         {
1685                                 unsigned char a = iptr[x*2];
1686                                 __put_user(a, optr++);
1687                                 __put_user(a, optr++);
1688                         }
1689                         /* and clear the rest of the line */
1690                         for (x*=2; optr<eptr && x<done->bpl; x++)
1691                                 __put_user(0, optr++);
1692                         /* next line */
1693                         iptr += done->bpl;
1694                 }
1695         }
1696         else {
1697                 /*
1698                  * Other (probably newer) programs asked
1699                  * us what geometry we are using, and are
1700                  * reading the correct size.
1701                  */
1702                 int x,y;
1703                 unsigned char* iptr = done->memadr+1;
1704                 for (y=done->h; optr<eptr && y<0; y++)
1705                 {
1706                         /* copy to doubled data to userland */
1707                         for (x=0; optr<eptr && x<-done->w; x++)
1708                                 __put_user(iptr[x*2], optr++);
1709                         /* and clear the rest of the line */
1710                         for (;optr<eptr && x<done->bpl; x++)
1711                                 __put_user(0, optr++);
1712                         /* next line */
1713                         iptr += done->bpl;
1714                 }
1715         }
1716
1717         /* API compliance:
1718          * place the framenumber (half fieldnr) in the last long
1719          */
1720         __put_user(done->fieldnr/2, ((ulong*)eptr)[-1]);
1721         }
1722
1723         /* keep the engine running */
1724         done->status = FBUFFER_FREE;
1725         zoran_cap(ztv, 1);
1726
1727         /* tell listeners this buffer just became free */
1728         wake_up_interruptible(&ztv->vbiq);
1729
1730         /* goodbye */
1731 out:
1732         DEBUG(printk(CARD_DEBUG "vbi_read() returns %lu\n",CARD,count));
1733         return count;
1734 }
1735
1736 static
1737 unsigned int vbi_poll(struct video_device *dev, struct file *file, poll_table *wait)
1738 {
1739         struct zoran *ztv = dev->priv;
1740         struct vidinfo* item;
1741         unsigned int mask = 0;
1742
1743         poll_wait(file, &ztv->vbiq, wait);
1744
1745         for (item=ztv->readinfo; item!=ztv->readinfo+ZORAN_VBI_BUFFERS; item++)
1746                 if (item->status == FBUFFER_DONE)
1747                 {
1748                         mask |= (POLLIN | POLLRDNORM);
1749                         break;
1750                 }
1751
1752         DEBUG(printk(CARD_DEBUG "vbi_poll()=%x\n",CARD,mask));
1753
1754         return mask;
1755 }
1756
1757 static
1758 int vbi_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
1759 {
1760         struct zoran* ztv = dev->priv;
1761
1762         switch (cmd) {
1763          case VIDIOCGVBIFMT:
1764          {
1765                 struct vbi_format f;
1766                 DEBUG(printk(CARD_DEBUG "VIDIOCGVBIINFO\n",CARD));
1767                 f.sampling_rate = 14750000UL;
1768                 f.samples_per_line = -ztv->readinfo[0].w;
1769                 f.sample_format = VIDEO_PALETTE_RAW;
1770                 f.start[0] = f.start[1] = ztv->readinfo[0].y;
1771                 f.start[1] += 312;
1772                 f.count[0] = f.count[1] = -ztv->readinfo[0].h;
1773                 f.flags = VBI_INTERLACED;
1774                 if (copy_to_user(arg,&f,sizeof(f)))
1775                         return -EFAULT;
1776                 break;
1777          }
1778          case VIDIOCSVBIFMT:
1779          {
1780                 struct vbi_format f;
1781                 int i;
1782                 if (copy_from_user(&f, arg,sizeof(f)))
1783                         return -EFAULT;
1784                 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));
1785
1786                 /* lots of parameters are fixed... (PAL) */
1787                 if (f.sampling_rate != 14750000UL ||
1788                     f.samples_per_line > 864 ||
1789                     f.sample_format != VIDEO_PALETTE_RAW ||
1790                     f.start[0] < 0 ||
1791                     f.start[0] != f.start[1]-312 ||
1792                     f.count[0] != f.count[1] ||
1793                     f.start[0]+f.count[0] >= 288 ||
1794                     f.flags != VBI_INTERLACED)
1795                         return -EINVAL;
1796
1797                 write_lock_irq(&ztv->lock);
1798                 ztv->readinfo[0].y = f.start[0];
1799                 ztv->readinfo[0].w = -f.samples_per_line;
1800                 ztv->readinfo[0].h = -f.count[0];
1801                 ztv->readinfo[0].bpl = f.samples_per_line*ztv->readinfo[0].bpp;
1802                 for (i=1; i<ZORAN_VBI_BUFFERS; i++)
1803                         ztv->readinfo[i] = ztv->readinfo[i];
1804                 write_unlock_irq(&ztv->lock);
1805                 break;
1806          }
1807          default:
1808                 return -ENOIOCTLCMD;
1809         }
1810         return 0;
1811 }
1812
1813 static struct video_device vbi_template=
1814 {
1815         .owner          = THIS_MODULE,
1816         .name           = "UNSET",
1817         .type           = VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
1818         .hardware       = VID_HARDWARE_ZR36120,
1819         .open           = vbi_open,
1820         .close          = vbi_close,
1821         .read           = vbi_read,
1822         .write          = zoran_write,
1823         .poll           = vbi_poll,
1824         .ioctl          = vbi_ioctl,
1825         .minor          = -1,
1826 };
1827
1828 /*
1829  *      Scan for a Zoran chip, request the irq and map the io memory
1830  */
1831 static
1832 int __init find_zoran(void)
1833 {
1834         int result;
1835         struct zoran *ztv;
1836         struct pci_dev *dev = NULL;
1837         unsigned char revision;
1838         int zoran_num=0;
1839
1840         while ((dev = pci_find_device(PCI_VENDOR_ID_ZORAN,PCI_DEVICE_ID_ZORAN_36120, dev)))
1841         {
1842                 /* Ok, a ZR36120/ZR36125 found! */
1843                 ztv = &zorans[zoran_num];
1844                 ztv->dev = dev;
1845
1846                 if (pci_enable_device(dev))
1847                         return -EIO;
1848
1849                 pci_read_config_byte(dev, PCI_CLASS_REVISION, &revision);
1850                 printk(KERN_INFO "zoran: Zoran %x (rev %d) ",
1851                         dev->device, revision);
1852                 printk("bus: %d, devfn: %d, irq: %d, ",
1853                         dev->bus->number, dev->devfn, dev->irq);
1854                 printk("memory: 0x%08lx.\n", ztv->zoran_adr);
1855
1856                 ztv->zoran_mem = ioremap(ztv->zoran_adr, 0x1000);
1857                 DEBUG(printk(KERN_DEBUG "zoran: mapped-memory at 0x%p\n",ztv->zoran_mem));
1858
1859                 result = request_irq(dev->irq, zoran_irq,
1860                         SA_SHIRQ|SA_INTERRUPT,"zoran", ztv);
1861                 if (result==-EINVAL)
1862                 {
1863                         iounmap(ztv->zoran_mem);
1864                         printk(KERN_ERR "zoran: Bad irq number or handler\n");
1865                         return -EINVAL;
1866                 }
1867                 if (result==-EBUSY)
1868                         printk(KERN_ERR "zoran: IRQ %d busy, change your PnP config in BIOS\n",dev->irq);
1869                 if (result < 0) {
1870                         iounmap(ztv->zoran_mem);
1871                         return result;
1872                 }
1873                 /* Enable bus-mastering */
1874                 pci_set_master(dev);
1875
1876                 zoran_num++;
1877         }
1878         if(zoran_num)
1879                 printk(KERN_INFO "zoran: %d Zoran card(s) found.\n",zoran_num);
1880         return zoran_num;
1881 }
1882
1883 static
1884 int __init init_zoran(int card)
1885 {
1886         struct zoran *ztv = &zorans[card];
1887         int     i;
1888
1889         /* if the given cardtype valid? */
1890         if (cardtype[card]>=NRTVCARDS) {
1891                 printk(KERN_INFO "invalid cardtype(%d) detected\n",cardtype[card]);
1892                 return -1;
1893         }
1894
1895         /* reset the zoran */
1896         zrand(~ZORAN_PCI_SOFTRESET,ZORAN_PCI);
1897         udelay(10);
1898         zror(ZORAN_PCI_SOFTRESET,ZORAN_PCI);
1899         udelay(10);
1900
1901         /* zoran chip specific details */
1902         ztv->card = tvcards+cardtype[card];     /* point to the selected card */
1903         ztv->norm = 0;                          /* PAL */
1904         ztv->tuner_freq = 0;
1905
1906         /* videocard details */
1907         ztv->swidth = 800;
1908         ztv->sheight = 600;
1909         ztv->depth = 16;
1910
1911         /* State details */
1912         ztv->fbuffer = 0;
1913         ztv->overinfo.kindof = FBUFFER_OVERLAY;
1914         ztv->overinfo.status = FBUFFER_FREE;
1915         ztv->overinfo.x = 0;
1916         ztv->overinfo.y = 0;
1917         ztv->overinfo.w = 768; /* 640 */
1918         ztv->overinfo.h = 576; /* 480 */
1919         ztv->overinfo.format = VIDEO_PALETTE_RGB565;
1920         ztv->overinfo.bpp = palette2fmt[ztv->overinfo.format].bpp;
1921         ztv->overinfo.bpl = ztv->overinfo.bpp*ztv->swidth;
1922         ztv->overinfo.busadr = 0;
1923         ztv->overinfo.memadr = 0;
1924         ztv->overinfo.overlay = 0;
1925         for (i=0; i<ZORAN_MAX_FBUFFERS; i++) {
1926                 ztv->grabinfo[i] = ztv->overinfo;
1927                 ztv->grabinfo[i].kindof = FBUFFER_GRAB;
1928         }
1929         init_waitqueue_head(&ztv->grabq);
1930
1931         /* VBI details */
1932         ztv->readinfo[0] = ztv->overinfo;
1933         ztv->readinfo[0].kindof = FBUFFER_VBI;
1934         ztv->readinfo[0].w = -864;
1935         ztv->readinfo[0].h = -38;
1936         ztv->readinfo[0].format = VIDEO_PALETTE_YUV422;
1937         ztv->readinfo[0].bpp = palette2fmt[ztv->readinfo[0].format].bpp;
1938         ztv->readinfo[0].bpl = 1024*ztv->readinfo[0].bpp;
1939         for (i=1; i<ZORAN_VBI_BUFFERS; i++)
1940                 ztv->readinfo[i] = ztv->readinfo[0];
1941         init_waitqueue_head(&ztv->vbiq);
1942
1943         /* maintenance data */
1944         ztv->have_decoder = 0;
1945         ztv->have_tuner = 0;
1946         ztv->tuner_type = 0;
1947         ztv->running = 0;
1948         ztv->users = 0;
1949         rwlock_init(&ztv->lock);
1950         ztv->workqueue = 0;
1951         ztv->fieldnr = 0;
1952         ztv->lastfieldnr = 0;
1953
1954         if (triton1)
1955                 zrand(~ZORAN_VDC_TRICOM, ZORAN_VDC);
1956
1957         /* external FL determines TOP frame */
1958         zror(ZORAN_VFEC_EXTFL, ZORAN_VFEC); 
1959
1960         /* set HSpol */
1961         if (ztv->card->hsync_pos)
1962                 zrwrite(ZORAN_VFEH_HSPOL, ZORAN_VFEH);
1963         /* set VSpol */
1964         if (ztv->card->vsync_pos)
1965                 zrwrite(ZORAN_VFEV_VSPOL, ZORAN_VFEV);
1966
1967         /* Set the proper General Purpuse register bits */
1968         /* implicit: no softreset, 0 waitstates */
1969         zrwrite(ZORAN_PCI_SOFTRESET|(ztv->card->gpdir<<0),ZORAN_PCI);
1970         /* implicit: 3 duration and recovery PCI clocks on guest 0-3 */
1971         zrwrite(ztv->card->gpval<<24,ZORAN_GUEST);
1972
1973         /* clear interrupt status */
1974         zrwrite(~0, ZORAN_ISR);
1975
1976         /*
1977          * i2c template
1978          */
1979         ztv->i2c = zoran_i2c_bus_template;
1980         sprintf(ztv->i2c.name,"zoran-%d",card);
1981         ztv->i2c.data = ztv;
1982
1983         /*
1984          * Now add the template and register the device unit
1985          */
1986         ztv->video_dev = zr36120_template;
1987         strcpy(ztv->video_dev.name, ztv->i2c.name);
1988         ztv->video_dev.priv = ztv;
1989         if (video_register_device(&ztv->video_dev, VFL_TYPE_GRABBER, video_nr) < 0)
1990                 return -1;
1991
1992         ztv->vbi_dev = vbi_template;
1993         strcpy(ztv->vbi_dev.name, ztv->i2c.name);
1994         ztv->vbi_dev.priv = ztv;
1995         if (video_register_device(&ztv->vbi_dev, VFL_TYPE_VBI, vbi_nr) < 0) {
1996                 video_unregister_device(&ztv->video_dev);
1997                 return -1;
1998         }
1999         i2c_register_bus(&ztv->i2c);
2000
2001         /* set interrupt mask - the PIN enable will be set later */
2002         zrwrite(ZORAN_ICR_GIRQ0|ZORAN_ICR_GIRQ1|ZORAN_ICR_CODE, ZORAN_ICR);
2003
2004         printk(KERN_INFO "%s: installed %s\n",ztv->i2c.name,ztv->card->name);
2005         return 0;
2006 }
2007
2008 static
2009 void release_zoran(int max)
2010 {
2011         struct zoran *ztv;
2012         int i;
2013
2014         for (i=0;i<max; i++) 
2015         {
2016                 ztv = &zorans[i];
2017
2018                 /* turn off all capturing, DMA and IRQs */
2019                 /* reset the zoran */
2020                 zrand(~ZORAN_PCI_SOFTRESET,ZORAN_PCI);
2021                 udelay(10);
2022                 zror(ZORAN_PCI_SOFTRESET,ZORAN_PCI);
2023                 udelay(10);
2024
2025                 /* first disable interrupts before unmapping the memory! */
2026                 zrwrite(0, ZORAN_ICR);
2027                 zrwrite(0xffffffffUL,ZORAN_ISR);
2028
2029                 /* free it */
2030                 free_irq(ztv->dev->irq,ztv);
2031  
2032                 /* unregister i2c_bus */
2033                 i2c_unregister_bus((&ztv->i2c));
2034
2035                 /* unmap and free memory */
2036                 if (ztv->zoran_mem)
2037                         iounmap(ztv->zoran_mem);
2038
2039                 video_unregister_device(&ztv->video_dev);
2040                 video_unregister_device(&ztv->vbi_dev);
2041         }
2042 }
2043
2044 void __exit zr36120_exit(void)
2045 {
2046         release_zoran(zoran_cards);
2047 }
2048
2049 int __init zr36120_init(void)
2050 {
2051         int     card;
2052  
2053         handle_chipset();
2054         zoran_cards = find_zoran();
2055         if (zoran_cards<0)
2056                 /* no cards found, no need for a driver */
2057                 return -EIO;
2058
2059         /* initialize Zorans */
2060         for (card=0; card<zoran_cards; card++) {
2061                 if (init_zoran(card)<0) {
2062                         /* only release the zorans we have registered */
2063                         release_zoran(card);
2064                         return -EIO;
2065                 } 
2066         }
2067         return 0;
2068 }
2069
2070 module_init(zr36120_init);
2071 module_exit(zr36120_exit);