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