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