?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Add tagged status support.
[linux-2.6/verdex.git] / drivers / media / video / zr36120.c
blobc33533155cc7242f9954dfd8a80ea5d4ae710625
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);
Verdex Pro support