2 * Zoran zr36057/zr36067 PCI controller driver, for the
3 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
4 * Media Labs LML33/LML33R10.
6 * This part handles card-specific data and detection
8 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
10 * Currently maintained by:
11 * Ronald Bultje <rbultje@ronald.bitfreak.net>
12 * Laurent Pinchart <laurent.pinchart@skynet.be>
13 * Mailinglist <mjpeg-users@lists.sf.net>
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 #include <linux/delay.h>
32 #include <linux/types.h>
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/vmalloc.h>
37 #include <linux/slab.h>
39 #include <linux/proc_fs.h>
40 #include <linux/i2c.h>
41 #include <linux/i2c-algo-bit.h>
42 #include <linux/videodev2.h>
43 #include <linux/spinlock.h>
44 #include <linux/sem.h>
45 #include <linux/kmod.h>
46 #include <linux/wait.h>
48 #include <linux/pci.h>
49 #include <linux/interrupt.h>
50 #include <linux/mutex.h>
52 #include <media/v4l2-common.h>
53 #include <media/bt819.h>
55 #include "videocodec.h"
57 #include "zoran_card.h"
58 #include "zoran_device.h"
59 #include "zoran_procfs.h"
61 extern const struct zoran_format zoran_formats
[];
63 static int card
[BUZ_MAX
] = { [0 ... (BUZ_MAX
-1)] = -1 };
64 module_param_array(card
, int, NULL
, 0444);
65 MODULE_PARM_DESC(card
, "Card type");
67 static int encoder
[BUZ_MAX
] = { [0 ... (BUZ_MAX
-1)] = -1 };
68 module_param_array(encoder
, int, NULL
, 0444);
69 MODULE_PARM_DESC(encoder
, "Video encoder chip");
71 static int decoder
[BUZ_MAX
] = { [0 ... (BUZ_MAX
-1)] = -1 };
72 module_param_array(decoder
, int, NULL
, 0444);
73 MODULE_PARM_DESC(decoder
, "Video decoder chip");
76 The video mem address of the video card.
77 The driver has a little database for some videocards
78 to determine it from there. If your video card is not in there
79 you have either to give it to the driver as a parameter
80 or set in in a VIDIOCSFBUF ioctl
83 static unsigned long vidmem
; /* default = 0 - Video memory base address */
84 module_param(vidmem
, ulong
, 0444);
85 MODULE_PARM_DESC(vidmem
, "Default video memory base address");
88 Default input and video norm at startup of the driver.
91 static unsigned int default_input
; /* default 0 = Composite, 1 = S-Video */
92 module_param(default_input
, uint
, 0444);
93 MODULE_PARM_DESC(default_input
,
94 "Default input (0=Composite, 1=S-Video, 2=Internal)");
96 static int default_mux
= 1; /* 6 Eyes input selection */
97 module_param(default_mux
, int, 0644);
98 MODULE_PARM_DESC(default_mux
,
99 "Default 6 Eyes mux setting (Input selection)");
101 static int default_norm
; /* default 0 = PAL, 1 = NTSC 2 = SECAM */
102 module_param(default_norm
, int, 0444);
103 MODULE_PARM_DESC(default_norm
, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
105 /* /dev/videoN, -1 for autodetect */
106 static int video_nr
[BUZ_MAX
] = { [0 ... (BUZ_MAX
-1)] = -1 };
107 module_param_array(video_nr
, int, NULL
, 0444);
108 MODULE_PARM_DESC(video_nr
, "Video device number (-1=Auto)");
111 int v4l_bufsize
= 864; /* Everybody should be able to work with this setting */
112 module_param(v4l_nbufs
, int, 0644);
113 MODULE_PARM_DESC(v4l_nbufs
, "Maximum number of V4L buffers to use");
114 module_param(v4l_bufsize
, int, 0644);
115 MODULE_PARM_DESC(v4l_bufsize
, "Maximum size per V4L buffer (in kB)");
118 int jpg_bufsize
= 512; /* max size for 100% quality full-PAL frame */
119 module_param(jpg_nbufs
, int, 0644);
120 MODULE_PARM_DESC(jpg_nbufs
, "Maximum number of JPG buffers to use");
121 module_param(jpg_bufsize
, int, 0644);
122 MODULE_PARM_DESC(jpg_bufsize
, "Maximum size per JPG buffer (in kB)");
124 int pass_through
= 0; /* 1=Pass through TV signal when device is not used */
125 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
126 module_param(pass_through
, int, 0644);
127 MODULE_PARM_DESC(pass_through
,
128 "Pass TV signal through to TV-out when idling");
130 int zr36067_debug
= 1;
131 module_param_named(debug
, zr36067_debug
, int, 0644);
132 MODULE_PARM_DESC(debug
, "Debug level (0-5)");
134 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
135 MODULE_AUTHOR("Serguei Miridonov");
136 MODULE_LICENSE("GPL");
138 #define ZR_DEVICE(subven, subdev, data) { \
139 .vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \
140 .subvendor = (subven), .subdevice = (subdev), .driver_data = (data) }
142 static struct pci_device_id zr36067_pci_tbl
[] = {
143 ZR_DEVICE(PCI_VENDOR_ID_MIRO
, PCI_DEVICE_ID_MIRO_DC10PLUS
, DC10plus
),
144 ZR_DEVICE(PCI_VENDOR_ID_MIRO
, PCI_DEVICE_ID_MIRO_DC30PLUS
, DC30plus
),
145 ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH
, PCI_DEVICE_ID_LML_33R10
, LML33R10
),
146 ZR_DEVICE(PCI_VENDOR_ID_IOMEGA
, PCI_DEVICE_ID_IOMEGA_BUZ
, BUZ
),
147 ZR_DEVICE(PCI_ANY_ID
, PCI_ANY_ID
, NUM_CARDS
),
150 MODULE_DEVICE_TABLE(pci
, zr36067_pci_tbl
);
152 static unsigned int zoran_num
; /* number of cards found */
154 /* videocodec bus functions ZR36060 */
156 zr36060_read (struct videocodec
*codec
,
159 struct zoran
*zr
= (struct zoran
*) codec
->master_data
->data
;
162 if (post_office_wait(zr
)
163 || post_office_write(zr
, 0, 1, reg
>> 8)
164 || post_office_write(zr
, 0, 2, reg
& 0xff)) {
168 data
= post_office_read(zr
, 0, 3) & 0xff;
173 zr36060_write (struct videocodec
*codec
,
177 struct zoran
*zr
= (struct zoran
*) codec
->master_data
->data
;
179 if (post_office_wait(zr
)
180 || post_office_write(zr
, 0, 1, reg
>> 8)
181 || post_office_write(zr
, 0, 2, reg
& 0xff)) {
185 post_office_write(zr
, 0, 3, val
& 0xff);
188 /* videocodec bus functions ZR36050 */
190 zr36050_read (struct videocodec
*codec
,
193 struct zoran
*zr
= (struct zoran
*) codec
->master_data
->data
;
196 if (post_office_wait(zr
)
197 || post_office_write(zr
, 1, 0, reg
>> 2)) { // reg. HIGHBYTES
201 data
= post_office_read(zr
, 0, reg
& 0x03) & 0xff; // reg. LOWBYTES + read
206 zr36050_write (struct videocodec
*codec
,
210 struct zoran
*zr
= (struct zoran
*) codec
->master_data
->data
;
212 if (post_office_wait(zr
)
213 || post_office_write(zr
, 1, 0, reg
>> 2)) { // reg. HIGHBYTES
217 post_office_write(zr
, 0, reg
& 0x03, val
& 0xff); // reg. LOWBYTES + wr. data
220 /* videocodec bus functions ZR36016 */
222 zr36016_read (struct videocodec
*codec
,
225 struct zoran
*zr
= (struct zoran
*) codec
->master_data
->data
;
228 if (post_office_wait(zr
)) {
232 data
= post_office_read(zr
, 2, reg
& 0x03) & 0xff; // read
236 /* hack for in zoran_device.c */
238 zr36016_write (struct videocodec
*codec
,
242 struct zoran
*zr
= (struct zoran
*) codec
->master_data
->data
;
244 if (post_office_wait(zr
)) {
248 post_office_write(zr
, 2, reg
& 0x03, val
& 0x0ff); // wr. data
252 * Board specific information
256 dc10_init (struct zoran
*zr
)
258 dprintk(3, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
260 /* Pixel clock selection */
263 /* Enable the video bus sync signals */
268 dc10plus_init (struct zoran
*zr
)
270 dprintk(3, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
274 buz_init (struct zoran
*zr
)
276 dprintk(3, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
278 /* some stuff from Iomega */
279 pci_write_config_dword(zr
->pci_dev
, 0xfc, 0x90680f15);
280 pci_write_config_dword(zr
->pci_dev
, 0x0c, 0x00012020);
281 pci_write_config_dword(zr
->pci_dev
, 0xe8, 0xc0200000);
285 lml33_init (struct zoran
*zr
)
287 dprintk(3, KERN_DEBUG
"%s: %s\n", ZR_DEVNAME(zr
), __func__
);
289 GPIO(zr
, 2, 1); // Set Composite input/output
293 avs6eyes_init (struct zoran
*zr
)
295 // AverMedia 6-Eyes original driver by Christer Weinigel
297 // Lifted straight from Christer's old driver and
298 // modified slightly by Martin Samuelsson.
300 int mux
= default_mux
; /* 1 = BT866, 7 = VID1 */
302 GPIO(zr
, 4, 1); /* Bt866 SLEEP on */
305 GPIO(zr
, 0, 1); /* ZR36060 /RESET on */
306 GPIO(zr
, 1, 0); /* ZR36060 /SLEEP on */
307 GPIO(zr
, 2, mux
& 1); /* MUX S0 */
308 GPIO(zr
, 3, 0); /* /FRAME on */
309 GPIO(zr
, 4, 0); /* Bt866 SLEEP off */
310 GPIO(zr
, 5, mux
& 2); /* MUX S1 */
311 GPIO(zr
, 6, 0); /* ? */
312 GPIO(zr
, 7, mux
& 4); /* MUX S2 */
317 codecid_to_modulename (u16 codecid
)
322 case CODEC_TYPE_ZR36060
:
325 case CODEC_TYPE_ZR36050
:
328 case CODEC_TYPE_ZR36016
:
337 // u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
340 static struct tvnorm f50sqpixel
= { 944, 768, 83, 880, 625, 576, 16 };
341 static struct tvnorm f60sqpixel
= { 780, 640, 51, 716, 525, 480, 12 };
342 static struct tvnorm f50ccir601
= { 864, 720, 75, 804, 625, 576, 18 };
343 static struct tvnorm f60ccir601
= { 858, 720, 57, 788, 525, 480, 16 };
345 static struct tvnorm f50ccir601_lml33
= { 864, 720, 75+34, 804, 625, 576, 18 };
346 static struct tvnorm f60ccir601_lml33
= { 858, 720, 57+34, 788, 525, 480, 16 };
348 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
349 static struct tvnorm f50sqpixel_dc10
= { 944, 768, 0, 880, 625, 576, 0 };
350 static struct tvnorm f60sqpixel_dc10
= { 780, 640, 0, 716, 525, 480, 12 };
352 /* FIXME: I cannot swap U and V in saa7114, so i do one
353 * pixel left shift in zoran (75 -> 74)
354 * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
355 static struct tvnorm f50ccir601_lm33r10
= { 864, 720, 74+54, 804, 625, 576, 18 };
356 static struct tvnorm f60ccir601_lm33r10
= { 858, 720, 56+54, 788, 525, 480, 16 };
358 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
359 * copy Maxim's left shift hack for the 6 Eyes.
361 * Christer's driver used the unshifted norms, though...
363 static struct tvnorm f50ccir601_avs6eyes
= { 864, 720, 74, 804, 625, 576, 18 };
364 static struct tvnorm f60ccir601_avs6eyes
= { 858, 720, 56, 788, 525, 480, 16 };
366 static const unsigned short vpx3220_addrs
[] = { 0x43, 0x47, I2C_CLIENT_END
};
367 static const unsigned short saa7110_addrs
[] = { 0x4e, 0x4f, I2C_CLIENT_END
};
368 static const unsigned short saa7111_addrs
[] = { 0x25, 0x24, I2C_CLIENT_END
};
369 static const unsigned short saa7114_addrs
[] = { 0x21, 0x20, I2C_CLIENT_END
};
370 static const unsigned short adv717x_addrs
[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END
};
371 static const unsigned short ks0127_addrs
[] = { 0x6c, 0x6d, I2C_CLIENT_END
};
372 static const unsigned short saa7185_addrs
[] = { 0x44, I2C_CLIENT_END
};
373 static const unsigned short bt819_addrs
[] = { 0x45, I2C_CLIENT_END
};
374 static const unsigned short bt856_addrs
[] = { 0x44, I2C_CLIENT_END
};
375 static const unsigned short bt866_addrs
[] = { 0x44, I2C_CLIENT_END
};
377 static struct card_info zoran_cards
[NUM_CARDS
] __devinitdata
= {
381 .i2c_decoder
= "vpx3220a",
382 .addrs_decoder
= vpx3220_addrs
,
383 .video_codec
= CODEC_TYPE_ZR36050
,
384 .video_vfe
= CODEC_TYPE_ZR36016
,
390 { 0, "Internal/comp" }
392 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
|V4L2_STD_SECAM
,
399 .vsync_int
= ZR36057_ISR_GIRQ1
,
400 .gpio
= { 2, 1, -1, 3, 7, 0, 4, 5 },
401 .gpio_pol
= { 0, 0, 0, 1, 0, 0, 0, 0 },
403 .vfe_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 },
404 .gws_not_connected
= 0,
410 .i2c_decoder
= "saa7110",
411 .addrs_decoder
= saa7110_addrs
,
412 .i2c_encoder
= "adv7175",
413 .addrs_encoder
= adv717x_addrs
,
414 .video_codec
= CODEC_TYPE_ZR36060
,
420 { 5, "Internal/comp" }
422 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
|V4L2_STD_SECAM
,
427 .jpeg_int
= ZR36057_ISR_GIRQ0
,
428 .vsync_int
= ZR36057_ISR_GIRQ1
,
429 .gpio
= { 3, 0, 6, 1, 2, -1, 4, 5 },
430 .gpio_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 },
432 .vfe_pol
= { 1, 1, 1, 1, 0, 0, 0, 0 },
433 .gws_not_connected
= 0,
435 .init
= &dc10plus_init
,
439 .i2c_decoder
= "saa7110",
440 .addrs_decoder
= saa7110_addrs
,
441 .i2c_encoder
= "adv7175",
442 .addrs_encoder
= adv717x_addrs
,
443 .video_codec
= CODEC_TYPE_ZR36060
,
449 { 5, "Internal/comp" }
451 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
|V4L2_STD_SECAM
,
457 .jpeg_int
= ZR36057_ISR_GIRQ0
,
458 .vsync_int
= ZR36057_ISR_GIRQ1
,
459 .gpio
= { 3, 0, 6, 1, 2, -1, 4, 5 },
460 .gpio_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 },
462 .vfe_pol
= { 1, 1, 1, 1, 0, 0, 0, 0 },
463 .gws_not_connected
= 0,
465 .init
= &dc10plus_init
,
469 .i2c_decoder
= "vpx3220a",
470 .addrs_decoder
= vpx3220_addrs
,
471 .i2c_encoder
= "adv7175",
472 .addrs_encoder
= adv717x_addrs
,
473 .video_codec
= CODEC_TYPE_ZR36050
,
474 .video_vfe
= CODEC_TYPE_ZR36016
,
480 { 0, "Internal/comp" }
482 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
|V4L2_STD_SECAM
,
489 .vsync_int
= ZR36057_ISR_GIRQ1
,
490 .gpio
= { 2, 1, -1, 3, 7, 0, 4, 5 },
491 .gpio_pol
= { 0, 0, 0, 1, 0, 0, 0, 0 },
493 .vfe_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 },
494 .gws_not_connected
= 0,
500 .i2c_decoder
= "vpx3220a",
501 .addrs_decoder
= vpx3220_addrs
,
502 .i2c_encoder
= "adv7175",
503 .addrs_encoder
= adv717x_addrs
,
504 .video_codec
= CODEC_TYPE_ZR36050
,
505 .video_vfe
= CODEC_TYPE_ZR36016
,
511 { 0, "Internal/comp" }
513 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
|V4L2_STD_SECAM
,
520 .vsync_int
= ZR36057_ISR_GIRQ1
,
521 .gpio
= { 2, 1, -1, 3, 7, 0, 4, 5 },
522 .gpio_pol
= { 0, 0, 0, 1, 0, 0, 0, 0 },
524 .vfe_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 },
525 .gws_not_connected
= 0,
531 .i2c_decoder
= "bt819a",
532 .addrs_decoder
= bt819_addrs
,
533 .i2c_encoder
= "bt856",
534 .addrs_encoder
= bt856_addrs
,
535 .video_codec
= CODEC_TYPE_ZR36060
,
542 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
,
548 .jpeg_int
= ZR36057_ISR_GIRQ1
,
549 .vsync_int
= ZR36057_ISR_GIRQ0
,
550 .gpio
= { 1, -1, 3, 5, 7, -1, -1, -1 },
551 .gpio_pol
= { 0, 0, 0, 0, 1, 0, 0, 0 },
553 .vfe_pol
= { 1, 1, 0, 0, 0, 1, 0, 0 },
554 .gws_not_connected
= 1,
560 .i2c_decoder
= "saa7114",
561 .addrs_decoder
= saa7114_addrs
,
562 .i2c_encoder
= "adv7170",
563 .addrs_encoder
= adv717x_addrs
,
564 .video_codec
= CODEC_TYPE_ZR36060
,
571 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
,
577 .jpeg_int
= ZR36057_ISR_GIRQ1
,
578 .vsync_int
= ZR36057_ISR_GIRQ0
,
579 .gpio
= { 1, -1, 3, 5, 7, -1, -1, -1 },
580 .gpio_pol
= { 0, 0, 0, 0, 1, 0, 0, 0 },
582 .vfe_pol
= { 1, 1, 0, 0, 0, 1, 0, 0 },
583 .gws_not_connected
= 1,
589 .i2c_decoder
= "saa7111",
590 .addrs_decoder
= saa7111_addrs
,
591 .i2c_encoder
= "saa7185",
592 .addrs_encoder
= saa7185_addrs
,
593 .video_codec
= CODEC_TYPE_ZR36060
,
600 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
|V4L2_STD_SECAM
,
606 .jpeg_int
= ZR36057_ISR_GIRQ1
,
607 .vsync_int
= ZR36057_ISR_GIRQ0
,
608 .gpio
= { 1, -1, 3, -1, -1, -1, -1, -1 },
609 .gpio_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 },
611 .vfe_pol
= { 1, 1, 0, 0, 0, 1, 0, 0 },
612 .gws_not_connected
= 1,
618 /* AverMedia chose not to brand the 6-Eyes. Thus it
619 can't be autodetected, and requires card=x. */
620 .i2c_decoder
= "ks0127",
621 .addrs_decoder
= ks0127_addrs
,
622 .i2c_encoder
= "bt866",
623 .addrs_encoder
= bt866_addrs
,
624 .video_codec
= CODEC_TYPE_ZR36060
,
628 { 0, "Composite 1" },
629 { 1, "Composite 2" },
630 { 2, "Composite 3" },
631 { 4, "Composite 4" },
632 { 5, "Composite 5" },
633 { 6, "Composite 6" },
639 .norms
= V4L2_STD_NTSC
|V4L2_STD_PAL
,
641 &f50ccir601_avs6eyes
,
642 &f60ccir601_avs6eyes
,
645 .jpeg_int
= ZR36057_ISR_GIRQ1
,
646 .vsync_int
= ZR36057_ISR_GIRQ0
,
647 .gpio
= { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
648 .gpio_pol
= { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
649 .gpcs
= { 3, 1 }, // Validity unknown /Sam
650 .vfe_pol
= { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam
651 .gws_not_connected
= 1,
653 .init
= &avs6eyes_init
,
661 /* software I2C functions */
663 zoran_i2c_getsda (void *data
)
665 struct zoran
*zr
= (struct zoran
*) data
;
667 return (btread(ZR36057_I2CBR
) >> 1) & 1;
671 zoran_i2c_getscl (void *data
)
673 struct zoran
*zr
= (struct zoran
*) data
;
675 return btread(ZR36057_I2CBR
) & 1;
679 zoran_i2c_setsda (void *data
,
682 struct zoran
*zr
= (struct zoran
*) data
;
688 btwrite(zr
->i2cbr
, ZR36057_I2CBR
);
692 zoran_i2c_setscl (void *data
,
695 struct zoran
*zr
= (struct zoran
*) data
;
701 btwrite(zr
->i2cbr
, ZR36057_I2CBR
);
704 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template
= {
705 .setsda
= zoran_i2c_setsda
,
706 .setscl
= zoran_i2c_setscl
,
707 .getsda
= zoran_i2c_getsda
,
708 .getscl
= zoran_i2c_getscl
,
714 zoran_register_i2c (struct zoran
*zr
)
716 memcpy(&zr
->i2c_algo
, &zoran_i2c_bit_data_template
,
717 sizeof(struct i2c_algo_bit_data
));
718 zr
->i2c_algo
.data
= zr
;
719 strlcpy(zr
->i2c_adapter
.name
, ZR_DEVNAME(zr
),
720 sizeof(zr
->i2c_adapter
.name
));
721 i2c_set_adapdata(&zr
->i2c_adapter
, &zr
->v4l2_dev
);
722 zr
->i2c_adapter
.algo_data
= &zr
->i2c_algo
;
723 zr
->i2c_adapter
.dev
.parent
= &zr
->pci_dev
->dev
;
724 return i2c_bit_add_bus(&zr
->i2c_adapter
);
728 zoran_unregister_i2c (struct zoran
*zr
)
730 i2c_del_adapter(&zr
->i2c_adapter
);
733 /* Check a zoran_params struct for correctness, insert default params */
736 zoran_check_jpg_settings (struct zoran
*zr
,
737 struct zoran_jpg_settings
*settings
,
740 int err
= 0, err0
= 0;
744 "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
745 ZR_DEVNAME(zr
), __func__
, settings
->decimation
, settings
->HorDcm
,
746 settings
->VerDcm
, settings
->TmpDcm
);
749 "%s: %s - x: %d, y: %d, w: %d, y: %d\n",
750 ZR_DEVNAME(zr
), __func__
, settings
->img_x
, settings
->img_y
,
751 settings
->img_width
, settings
->img_height
);
752 /* Check decimation, set default values for decimation = 1, 2, 4 */
753 switch (settings
->decimation
) {
756 settings
->HorDcm
= 1;
757 settings
->VerDcm
= 1;
758 settings
->TmpDcm
= 1;
759 settings
->field_per_buff
= 2;
762 settings
->img_width
= BUZ_MAX_WIDTH
;
763 settings
->img_height
= BUZ_MAX_HEIGHT
/ 2;
767 settings
->HorDcm
= 2;
768 settings
->VerDcm
= 1;
769 settings
->TmpDcm
= 2;
770 settings
->field_per_buff
= 1;
771 settings
->img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
773 settings
->img_width
=
774 (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
775 settings
->img_height
= BUZ_MAX_HEIGHT
/ 2;
779 if (zr
->card
.type
== DC10_new
) {
782 "%s: %s - HDec by 4 is not supported on the DC10\n",
783 ZR_DEVNAME(zr
), __func__
);
788 settings
->HorDcm
= 4;
789 settings
->VerDcm
= 2;
790 settings
->TmpDcm
= 2;
791 settings
->field_per_buff
= 1;
792 settings
->img_x
= (BUZ_MAX_WIDTH
== 720) ? 8 : 0;
794 settings
->img_width
=
795 (BUZ_MAX_WIDTH
== 720) ? 704 : BUZ_MAX_WIDTH
;
796 settings
->img_height
= BUZ_MAX_HEIGHT
/ 2;
800 /* We have to check the data the user has set */
802 if (settings
->HorDcm
!= 1 && settings
->HorDcm
!= 2 &&
803 (zr
->card
.type
== DC10_new
|| settings
->HorDcm
!= 4)) {
804 settings
->HorDcm
= clamp(settings
->HorDcm
, 1, 2);
807 if (settings
->VerDcm
!= 1 && settings
->VerDcm
!= 2) {
808 settings
->VerDcm
= clamp(settings
->VerDcm
, 1, 2);
811 if (settings
->TmpDcm
!= 1 && settings
->TmpDcm
!= 2) {
812 settings
->TmpDcm
= clamp(settings
->TmpDcm
, 1, 2);
815 if (settings
->field_per_buff
!= 1 &&
816 settings
->field_per_buff
!= 2) {
817 settings
->field_per_buff
= clamp(settings
->field_per_buff
, 1, 2);
820 if (settings
->img_x
< 0) {
824 if (settings
->img_y
< 0) {
828 if (settings
->img_width
< 0 || settings
->img_width
> BUZ_MAX_WIDTH
) {
829 settings
->img_width
= clamp(settings
->img_width
, 0, (int)BUZ_MAX_WIDTH
);
832 if (settings
->img_height
< 0 || settings
->img_height
> BUZ_MAX_HEIGHT
/ 2) {
833 settings
->img_height
= clamp(settings
->img_height
, 0, BUZ_MAX_HEIGHT
/ 2);
836 if (settings
->img_x
+ settings
->img_width
> BUZ_MAX_WIDTH
) {
837 settings
->img_x
= BUZ_MAX_WIDTH
- settings
->img_width
;
840 if (settings
->img_y
+ settings
->img_height
> BUZ_MAX_HEIGHT
/ 2) {
841 settings
->img_y
= BUZ_MAX_HEIGHT
/ 2 - settings
->img_height
;
844 if (settings
->img_width
% (16 * settings
->HorDcm
) != 0) {
845 settings
->img_width
-= settings
->img_width
% (16 * settings
->HorDcm
);
846 if (settings
->img_width
== 0)
847 settings
->img_width
= 16 * settings
->HorDcm
;
850 if (settings
->img_height
% (8 * settings
->VerDcm
) != 0) {
851 settings
->img_height
-= settings
->img_height
% (8 * settings
->VerDcm
);
852 if (settings
->img_height
== 0)
853 settings
->img_height
= 8 * settings
->VerDcm
;
860 "%s: %s - error in params for decimation = 0\n",
861 ZR_DEVNAME(zr
), __func__
);
868 "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n",
869 ZR_DEVNAME(zr
), __func__
, settings
->decimation
);
874 if (settings
->jpg_comp
.quality
> 100)
875 settings
->jpg_comp
.quality
= 100;
876 if (settings
->jpg_comp
.quality
< 5)
877 settings
->jpg_comp
.quality
= 5;
878 if (settings
->jpg_comp
.APPn
< 0)
879 settings
->jpg_comp
.APPn
= 0;
880 if (settings
->jpg_comp
.APPn
> 15)
881 settings
->jpg_comp
.APPn
= 15;
882 if (settings
->jpg_comp
.APP_len
< 0)
883 settings
->jpg_comp
.APP_len
= 0;
884 if (settings
->jpg_comp
.APP_len
> 60)
885 settings
->jpg_comp
.APP_len
= 60;
886 if (settings
->jpg_comp
.COM_len
< 0)
887 settings
->jpg_comp
.COM_len
= 0;
888 if (settings
->jpg_comp
.COM_len
> 60)
889 settings
->jpg_comp
.COM_len
= 60;
896 zoran_open_init_params (struct zoran
*zr
)
900 /* User must explicitly set a window */
901 zr
->overlay_settings
.is_set
= 0;
902 zr
->overlay_mask
= NULL
;
903 zr
->overlay_active
= ZORAN_FREE
;
905 zr
->v4l_memgrab_active
= 0;
906 zr
->v4l_overlay_active
= 0;
907 zr
->v4l_grab_frame
= NO_GRAB_ACTIVE
;
908 zr
->v4l_grab_seq
= 0;
909 zr
->v4l_settings
.width
= 192;
910 zr
->v4l_settings
.height
= 144;
911 zr
->v4l_settings
.format
= &zoran_formats
[7]; /* YUY2 - YUV-4:2:2 packed */
912 zr
->v4l_settings
.bytesperline
=
913 zr
->v4l_settings
.width
*
914 ((zr
->v4l_settings
.format
->depth
+ 7) / 8);
916 /* DMA ring stuff for V4L */
917 zr
->v4l_pend_tail
= 0;
918 zr
->v4l_pend_head
= 0;
919 zr
->v4l_sync_tail
= 0;
920 zr
->v4l_buffers
.active
= ZORAN_FREE
;
921 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
922 zr
->v4l_buffers
.buffer
[i
].state
= BUZ_STATE_USER
; /* nothing going on */
924 zr
->v4l_buffers
.allocated
= 0;
926 for (i
= 0; i
< BUZ_MAX_FRAME
; i
++) {
927 zr
->jpg_buffers
.buffer
[i
].state
= BUZ_STATE_USER
; /* nothing going on */
929 zr
->jpg_buffers
.active
= ZORAN_FREE
;
930 zr
->jpg_buffers
.allocated
= 0;
931 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
932 zr
->jpg_settings
.decimation
= 1;
933 zr
->jpg_settings
.jpg_comp
.quality
= 50; /* default compression factor 8 */
934 if (zr
->card
.type
!= BUZ
)
935 zr
->jpg_settings
.odd_even
= 1;
937 zr
->jpg_settings
.odd_even
= 0;
938 zr
->jpg_settings
.jpg_comp
.APPn
= 0;
939 zr
->jpg_settings
.jpg_comp
.APP_len
= 0; /* No APPn marker */
940 memset(zr
->jpg_settings
.jpg_comp
.APP_data
, 0,
941 sizeof(zr
->jpg_settings
.jpg_comp
.APP_data
));
942 zr
->jpg_settings
.jpg_comp
.COM_len
= 0; /* No COM marker */
943 memset(zr
->jpg_settings
.jpg_comp
.COM_data
, 0,
944 sizeof(zr
->jpg_settings
.jpg_comp
.COM_data
));
945 zr
->jpg_settings
.jpg_comp
.jpeg_markers
=
946 V4L2_JPEG_MARKER_DHT
| V4L2_JPEG_MARKER_DQT
;
947 i
= zoran_check_jpg_settings(zr
, &zr
->jpg_settings
, 0);
949 dprintk(1, KERN_ERR
"%s: %s internal error\n",
950 ZR_DEVNAME(zr
), __func__
);
952 clear_interrupt_counters(zr
);
956 static void __devinit
957 test_interrupts (struct zoran
*zr
)
962 clear_interrupt_counters(zr
);
965 icr
= btread(ZR36057_ICR
);
966 btwrite(0x78000000 | ZR36057_ICR_IntPinEn
, ZR36057_ICR
);
967 prepare_to_wait(&zr
->test_q
, &wait
, TASK_INTERRUPTIBLE
);
968 timeout
= schedule_timeout(HZ
);
969 finish_wait(&zr
->test_q
, &wait
);
970 btwrite(0, ZR36057_ICR
);
971 btwrite(0x78000000, ZR36057_ISR
);
973 dprintk(5, KERN_INFO
"%s: Testing interrupts...\n", ZR_DEVNAME(zr
));
975 dprintk(1, ": time spent: %d\n", 1 * HZ
- timeout
);
977 if (zr36067_debug
> 1)
978 print_interrupts(zr
);
979 btwrite(icr
, ZR36057_ICR
);
983 zr36057_init (struct zoran
*zr
)
989 "%s: %s - initializing card[%d], zr=%p\n",
990 ZR_DEVNAME(zr
), __func__
, zr
->id
, zr
);
992 /* default setup of all parameters which will persist between opens */
995 init_waitqueue_head(&zr
->v4l_capq
);
996 init_waitqueue_head(&zr
->jpg_capq
);
997 init_waitqueue_head(&zr
->test_q
);
998 zr
->jpg_buffers
.allocated
= 0;
999 zr
->v4l_buffers
.allocated
= 0;
1001 zr
->vbuf_base
= (void *) vidmem
;
1003 zr
->vbuf_height
= 0;
1005 zr
->vbuf_bytesperline
= 0;
1007 /* Avoid nonsense settings from user for default input/norm */
1008 if (default_norm
< 0 || default_norm
> 2)
1010 if (default_norm
== 0) {
1011 zr
->norm
= V4L2_STD_PAL
;
1012 zr
->timing
= zr
->card
.tvn
[0];
1013 } else if (default_norm
== 1) {
1014 zr
->norm
= V4L2_STD_NTSC
;
1015 zr
->timing
= zr
->card
.tvn
[1];
1017 zr
->norm
= V4L2_STD_SECAM
;
1018 zr
->timing
= zr
->card
.tvn
[2];
1020 if (zr
->timing
== NULL
) {
1023 "%s: %s - default TV standard not supported by hardware. PAL will be used.\n",
1024 ZR_DEVNAME(zr
), __func__
);
1025 zr
->norm
= V4L2_STD_PAL
;
1026 zr
->timing
= zr
->card
.tvn
[0];
1029 if (default_input
> zr
->card
.inputs
-1) {
1032 "%s: default_input value %d out of range (0-%d)\n",
1033 ZR_DEVNAME(zr
), default_input
, zr
->card
.inputs
-1);
1036 zr
->input
= default_input
;
1038 /* default setup (will be repeated at every open) */
1039 zoran_open_init_params(zr
);
1041 /* allocate memory *before* doing anything to the hardware
1042 * in case allocation fails */
1043 zr
->stat_com
= kzalloc(BUZ_NUM_STAT_COM
* 4, GFP_KERNEL
);
1044 zr
->video_dev
= video_device_alloc();
1045 if (!zr
->stat_com
|| !zr
->video_dev
) {
1048 "%s: %s - kmalloc (STAT_COM) failed\n",
1049 ZR_DEVNAME(zr
), __func__
);
1053 for (j
= 0; j
< BUZ_NUM_STAT_COM
; j
++) {
1054 zr
->stat_com
[j
] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1058 * Now add the template and register the device unit.
1060 memcpy(zr
->video_dev
, &zoran_template
, sizeof(zoran_template
));
1061 zr
->video_dev
->parent
= &zr
->pci_dev
->dev
;
1062 strcpy(zr
->video_dev
->name
, ZR_DEVNAME(zr
));
1063 err
= video_register_device(zr
->video_dev
, VFL_TYPE_GRABBER
, video_nr
[zr
->id
]);
1066 video_set_drvdata(zr
->video_dev
, zr
);
1068 zoran_init_hardware(zr
);
1069 if (zr36067_debug
> 2)
1070 detect_guest_activity(zr
);
1071 test_interrupts(zr
);
1072 if (!pass_through
) {
1073 decoder_call(zr
, video
, s_stream
, 0);
1074 encoder_call(zr
, video
, s_routing
, 2, 0, 0);
1077 zr
->zoran_proc
= NULL
;
1078 zr
->initialized
= 1;
1082 kfree(zr
->stat_com
);
1083 kfree(zr
->video_dev
);
1087 static void __devexit
zoran_remove(struct pci_dev
*pdev
)
1089 struct v4l2_device
*v4l2_dev
= dev_get_drvdata(&pdev
->dev
);
1090 struct zoran
*zr
= to_zoran(v4l2_dev
);
1092 if (!zr
->initialized
)
1095 /* unregister videocodec bus */
1097 struct videocodec_master
*master
= zr
->codec
->master_data
;
1099 videocodec_detach(zr
->codec
);
1103 struct videocodec_master
*master
= zr
->vfe
->master_data
;
1105 videocodec_detach(zr
->vfe
);
1109 /* unregister i2c bus */
1110 zoran_unregister_i2c(zr
);
1111 /* disable PCI bus-mastering */
1112 zoran_set_pci_master(zr
, 0);
1113 /* put chip into reset */
1114 btwrite(0, ZR36057_SPGPPCR
);
1115 free_irq(zr
->pci_dev
->irq
, zr
);
1116 /* unmap and free memory */
1117 kfree(zr
->stat_com
);
1118 zoran_proc_cleanup(zr
);
1119 iounmap(zr
->zr36057_mem
);
1120 pci_disable_device(zr
->pci_dev
);
1121 video_unregister_device(zr
->video_dev
);
1123 v4l2_device_unregister(&zr
->v4l2_dev
);
1128 zoran_vdev_release (struct video_device
*vdev
)
1133 static struct videocodec_master
* __devinit
1134 zoran_setup_videocodec (struct zoran
*zr
,
1137 struct videocodec_master
*m
= NULL
;
1139 m
= kmalloc(sizeof(struct videocodec_master
), GFP_KERNEL
);
1141 dprintk(1, KERN_ERR
"%s: %s - no memory\n",
1142 ZR_DEVNAME(zr
), __func__
);
1146 /* magic and type are unused for master struct. Makes sense only at
1148 In the past, .type were initialized to the old V4L1 .hardware
1149 value, as VID_HARDWARE_ZR36067
1154 m
->flags
= CODEC_FLAG_ENCODER
| CODEC_FLAG_DECODER
;
1155 strlcpy(m
->name
, ZR_DEVNAME(zr
), sizeof(m
->name
));
1160 case CODEC_TYPE_ZR36060
:
1161 m
->readreg
= zr36060_read
;
1162 m
->writereg
= zr36060_write
;
1163 m
->flags
|= CODEC_FLAG_JPEG
| CODEC_FLAG_VFE
;
1165 case CODEC_TYPE_ZR36050
:
1166 m
->readreg
= zr36050_read
;
1167 m
->writereg
= zr36050_write
;
1168 m
->flags
|= CODEC_FLAG_JPEG
;
1170 case CODEC_TYPE_ZR36016
:
1171 m
->readreg
= zr36016_read
;
1172 m
->writereg
= zr36016_write
;
1173 m
->flags
|= CODEC_FLAG_VFE
;
1180 static void zoran_subdev_notify(struct v4l2_subdev
*sd
, unsigned int cmd
, void *arg
)
1182 struct zoran
*zr
= to_zoran(sd
->v4l2_dev
);
1184 /* Bt819 needs to reset its FIFO buffer using #FRST pin and
1185 LML33 card uses GPIO(7) for that. */
1186 if (cmd
== BT819_FIFO_RESET_LOW
)
1188 else if (cmd
== BT819_FIFO_RESET_HIGH
)
1193 * Scan for a Buz card (actually for the PCI controller ZR36057),
1194 * request the irq and map the io memory
1196 static int __devinit
zoran_probe(struct pci_dev
*pdev
,
1197 const struct pci_device_id
*ent
)
1199 unsigned char latency
, need_latency
;
1202 struct videocodec_master
*master_vfe
= NULL
;
1203 struct videocodec_master
*master_codec
= NULL
;
1205 char *codec_name
, *vfe_name
;
1210 if (nr
>= BUZ_MAX
) {
1211 dprintk(1, KERN_ERR
"%s: driver limited to %d card(s) maximum\n",
1212 ZORAN_NAME
, BUZ_MAX
);
1216 zr
= kzalloc(sizeof(struct zoran
), GFP_KERNEL
);
1218 dprintk(1, KERN_ERR
"%s: %s - kzalloc failed\n",
1219 ZORAN_NAME
, __func__
);
1222 zr
->v4l2_dev
.notify
= zoran_subdev_notify
;
1223 if (v4l2_device_register(&pdev
->dev
, &zr
->v4l2_dev
))
1227 snprintf(ZR_DEVNAME(zr
), sizeof(ZR_DEVNAME(zr
)), "MJPEG[%u]", zr
->id
);
1228 spin_lock_init(&zr
->spinlock
);
1229 mutex_init(&zr
->resource_lock
);
1230 mutex_init(&zr
->other_lock
);
1231 if (pci_enable_device(pdev
))
1233 pci_read_config_byte(zr
->pci_dev
, PCI_CLASS_REVISION
, &zr
->revision
);
1237 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1238 ZR_DEVNAME(zr
), zr
->revision
< 2 ? '5' : '6', zr
->revision
,
1239 zr
->pci_dev
->irq
, (uint64_t)pci_resource_start(zr
->pci_dev
, 0));
1240 if (zr
->revision
>= 2) {
1243 "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1244 ZR_DEVNAME(zr
), zr
->pci_dev
->subsystem_vendor
,
1245 zr
->pci_dev
->subsystem_device
);
1248 /* Use auto-detected card type? */
1249 if (card
[nr
] == -1) {
1250 if (zr
->revision
< 2) {
1253 "%s: No card type specified, please use the card=X module parameter\n",
1257 "%s: It is not possible to auto-detect ZR36057 based cards\n",
1262 card_num
= ent
->driver_data
;
1263 if (card_num
>= NUM_CARDS
) {
1266 "%s: Unknown card, try specifying card=X module parameter\n",
1272 "%s: %s() - card %s detected\n",
1273 ZR_DEVNAME(zr
), __func__
, zoran_cards
[card_num
].name
);
1275 card_num
= card
[nr
];
1276 if (card_num
>= NUM_CARDS
|| card_num
< 0) {
1279 "%s: User specified card type %d out of range (0 .. %d)\n",
1280 ZR_DEVNAME(zr
), card_num
, NUM_CARDS
- 1);
1285 /* even though we make this a non pointer and thus
1286 * theoretically allow for making changes to this struct
1287 * on a per-individual card basis at runtime, this is
1288 * strongly discouraged. This structure is intended to
1289 * keep general card information, no settings or anything */
1290 zr
->card
= zoran_cards
[card_num
];
1291 snprintf(ZR_DEVNAME(zr
), sizeof(ZR_DEVNAME(zr
)),
1292 "%s[%u]", zr
->card
.name
, zr
->id
);
1294 zr
->zr36057_mem
= pci_ioremap_bar(zr
->pci_dev
, 0);
1295 if (!zr
->zr36057_mem
) {
1296 dprintk(1, KERN_ERR
"%s: %s() - ioremap failed\n",
1297 ZR_DEVNAME(zr
), __func__
);
1301 result
= request_irq(zr
->pci_dev
->irq
, zoran_irq
,
1302 IRQF_SHARED
| IRQF_DISABLED
, ZR_DEVNAME(zr
), zr
);
1304 if (result
== -EINVAL
) {
1307 "%s: %s - bad irq number or handler\n",
1308 ZR_DEVNAME(zr
), __func__
);
1309 } else if (result
== -EBUSY
) {
1312 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n",
1313 ZR_DEVNAME(zr
), __func__
, zr
->pci_dev
->irq
);
1317 "%s: %s - can't assign irq, error code %d\n",
1318 ZR_DEVNAME(zr
), __func__
, result
);
1323 /* set PCI latency timer */
1324 pci_read_config_byte(zr
->pci_dev
, PCI_LATENCY_TIMER
,
1326 need_latency
= zr
->revision
> 1 ? 32 : 48;
1327 if (latency
!= need_latency
) {
1328 dprintk(2, KERN_INFO
"%s: Changing PCI latency from %d to %d\n",
1329 ZR_DEVNAME(zr
), latency
, need_latency
);
1330 pci_write_config_byte(zr
->pci_dev
, PCI_LATENCY_TIMER
,
1334 zr36057_restart(zr
);
1336 dprintk(2, KERN_INFO
"%s: Initializing i2c bus...\n",
1339 if (zoran_register_i2c(zr
) < 0) {
1340 dprintk(1, KERN_ERR
"%s: %s - can't initialize i2c bus\n",
1341 ZR_DEVNAME(zr
), __func__
);
1345 zr
->decoder
= v4l2_i2c_new_subdev(&zr
->v4l2_dev
,
1346 &zr
->i2c_adapter
, zr
->card
.i2c_decoder
,
1347 0, zr
->card
.addrs_decoder
);
1349 if (zr
->card
.i2c_encoder
)
1350 zr
->encoder
= v4l2_i2c_new_subdev(&zr
->v4l2_dev
,
1351 &zr
->i2c_adapter
, zr
->card
.i2c_encoder
,
1352 0, zr
->card
.addrs_encoder
);
1355 KERN_INFO
"%s: Initializing videocodec bus...\n",
1358 if (zr
->card
.video_codec
) {
1359 codec_name
= codecid_to_modulename(zr
->card
.video_codec
);
1361 result
= request_module(codec_name
);
1365 "%s: failed to load modules %s: %d\n",
1366 ZR_DEVNAME(zr
), codec_name
, result
);
1370 if (zr
->card
.video_vfe
) {
1371 vfe_name
= codecid_to_modulename(zr
->card
.video_vfe
);
1373 result
= request_module(vfe_name
);
1377 "%s: failed to load modules %s: %d\n",
1378 ZR_DEVNAME(zr
), vfe_name
, result
);
1383 /* reset JPEG codec */
1384 jpeg_codec_sleep(zr
, 1);
1385 jpeg_codec_reset(zr
);
1386 /* video bus enabled */
1387 /* display codec revision */
1388 if (zr
->card
.video_codec
!= 0) {
1389 master_codec
= zoran_setup_videocodec(zr
, zr
->card
.video_codec
);
1392 zr
->codec
= videocodec_attach(master_codec
);
1394 dprintk(1, KERN_ERR
"%s: %s - no codec found\n",
1395 ZR_DEVNAME(zr
), __func__
);
1398 if (zr
->codec
->type
!= zr
->card
.video_codec
) {
1399 dprintk(1, KERN_ERR
"%s: %s - wrong codec\n",
1400 ZR_DEVNAME(zr
), __func__
);
1401 goto zr_detach_codec
;
1404 if (zr
->card
.video_vfe
!= 0) {
1405 master_vfe
= zoran_setup_videocodec(zr
, zr
->card
.video_vfe
);
1407 goto zr_detach_codec
;
1408 zr
->vfe
= videocodec_attach(master_vfe
);
1410 dprintk(1, KERN_ERR
"%s: %s - no VFE found\n",
1411 ZR_DEVNAME(zr
), __func__
);
1414 if (zr
->vfe
->type
!= zr
->card
.video_vfe
) {
1415 dprintk(1, KERN_ERR
"%s: %s = wrong VFE\n",
1416 ZR_DEVNAME(zr
), __func__
);
1421 /* take care of Natoma chipset and a revision 1 zr36057 */
1422 if ((pci_pci_problems
& PCIPCI_NATOMA
) && zr
->revision
<= 1) {
1423 zr
->jpg_buffers
.need_contiguous
= 1;
1424 dprintk(1, KERN_INFO
1425 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1429 if (zr36057_init(zr
) < 0)
1432 zoran_proc_init(zr
);
1437 videocodec_detach(zr
->vfe
);
1441 videocodec_detach(zr
->codec
);
1443 kfree(master_codec
);
1445 zoran_unregister_i2c(zr
);
1447 btwrite(0, ZR36057_SPGPPCR
);
1448 free_irq(zr
->pci_dev
->irq
, zr
);
1450 iounmap(zr
->zr36057_mem
);
1452 v4l2_device_unregister(&zr
->v4l2_dev
);
1459 static struct pci_driver zoran_driver
= {
1461 .id_table
= zr36067_pci_tbl
,
1462 .probe
= zoran_probe
,
1463 .remove
= __devexit_p(zoran_remove
),
1466 static int __init
zoran_init(void)
1470 printk(KERN_INFO
"Zoran MJPEG board driver version %d.%d.%d\n",
1471 MAJOR_VERSION
, MINOR_VERSION
, RELEASE_VERSION
);
1473 /* check the parameters we have been given, adjust if necessary */
1476 if (v4l_nbufs
> VIDEO_MAX_FRAME
)
1477 v4l_nbufs
= VIDEO_MAX_FRAME
;
1478 /* The user specfies the in KB, we want them in byte
1479 * (and page aligned) */
1480 v4l_bufsize
= PAGE_ALIGN(v4l_bufsize
* 1024);
1481 if (v4l_bufsize
< 32768)
1482 v4l_bufsize
= 32768;
1483 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1484 if (v4l_bufsize
> 2048 * 1024)
1485 v4l_bufsize
= 2048 * 1024;
1488 if (jpg_nbufs
> BUZ_MAX_FRAME
)
1489 jpg_nbufs
= BUZ_MAX_FRAME
;
1490 jpg_bufsize
= PAGE_ALIGN(jpg_bufsize
* 1024);
1491 if (jpg_bufsize
< 8192)
1493 if (jpg_bufsize
> (512 * 1024))
1494 jpg_bufsize
= 512 * 1024;
1495 /* Use parameter for vidmem or try to find a video card */
1499 "%s: Using supplied video memory base address @ 0x%lx\n",
1500 ZORAN_NAME
, vidmem
);
1503 /* some mainboards might not do PCI-PCI data transfer well */
1504 if (pci_pci_problems
& (PCIPCI_FAIL
|PCIAGP_FAIL
|PCIPCI_ALIMAGIK
)) {
1507 "%s: chipset does not support reliable PCI-PCI DMA\n",
1511 res
= pci_register_driver(&zoran_driver
);
1515 "%s: Unable to register ZR36057 driver\n",
1523 static void __exit
zoran_exit(void)
1525 pci_unregister_driver(&zoran_driver
);
1528 module_init(zoran_init
);
1529 module_exit(zoran_exit
);