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>
38 #include <linux/proc_fs.h>
39 #include <linux/i2c.h>
40 #include <linux/i2c-algo-bit.h>
41 #include <linux/videodev.h>
42 #include <media/v4l2-common.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/video_decoder.h>
51 #include <linux/video_encoder.h>
52 #include <linux/mutex.h>
56 #include "videocodec.h"
58 #include "zoran_card.h"
59 #include "zoran_device.h"
60 #include "zoran_procfs.h"
62 extern const struct zoran_format zoran_formats[];
64 static int card[BUZ_MAX] = { -1, -1, -1, -1 };
65 module_param_array(card, int, NULL, 0444);
66 MODULE_PARM_DESC(card, "The type of card");
68 static int encoder[BUZ_MAX] = { -1, -1, -1, -1 };
69 module_param_array(encoder, int, NULL, 0444);
70 MODULE_PARM_DESC(encoder, "i2c TV encoder");
72 static int decoder[BUZ_MAX] = { -1, -1, -1, -1 };
73 module_param_array(decoder, int, NULL, 0444);
74 MODULE_PARM_DESC(decoder, "i2c TV decoder");
77 The video mem address of the video card.
78 The driver has a little database for some videocards
79 to determine it from there. If your video card is not in there
80 you have either to give it to the driver as a parameter
81 or set in in a VIDIOCSFBUF ioctl
84 static unsigned long vidmem; /* default = 0 - Video memory base address */
85 module_param(vidmem, ulong, 0444);
86 MODULE_PARM_DESC(vidmem, "Default video memory base address");
89 Default input and video norm at startup of the driver.
92 static unsigned int default_input; /* default 0 = Composite, 1 = S-Video */
93 module_param(default_input, uint, 0444);
94 MODULE_PARM_DESC(default_input,
95 "Default input (0=Composite, 1=S-Video, 2=Internal)");
97 static int default_mux = 1; /* 6 Eyes input selection */
98 module_param(default_mux, int, 0644);
99 MODULE_PARM_DESC(default_mux,
100 "Default 6 Eyes mux setting (Input selection)");
102 static int default_norm; /* default 0 = PAL, 1 = NTSC 2 = SECAM */
103 module_param(default_norm, int, 0444);
104 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
106 /* /dev/videoN, -1 for autodetect */
107 static int video_nr[BUZ_MAX] = {-1, -1, -1, -1};
108 module_param_array(video_nr, int, NULL, 0444);
109 MODULE_PARM_DESC(video_nr, "video device number (-1=Auto)");
112 Number and size of grab buffers for Video 4 Linux
113 The vast majority of applications should not need more than 2,
114 the very popular BTTV driver actually does ONLY have 2.
115 Time sensitive applications might need more, the maximum
116 is VIDEO_MAX_FRAME (defined in <linux/videodev.h>).
118 The size is set so that the maximum possible request
119 can be satisfied. Decrease it, if bigphys_area alloc'd
120 memory is low. If you don't have the bigphys_area patch,
121 set it to 128 KB. Will you allow only to grab small
122 images with V4L, but that's better than nothing.
124 v4l_bufsize has to be given in KB !
129 int v4l_bufsize = 128; /* Everybody should be able to work with this setting */
130 module_param(v4l_nbufs, int, 0644);
131 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
132 module_param(v4l_bufsize, int, 0644);
133 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
136 int jpg_bufsize = 512; /* max size for 100% quality full-PAL frame */
137 module_param(jpg_nbufs, int, 0644);
138 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
139 module_param(jpg_bufsize, int, 0644);
140 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
142 int pass_through = 0; /* 1=Pass through TV signal when device is not used */
143 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
144 module_param(pass_through, int, 0644);
145 MODULE_PARM_DESC(pass_through,
146 "Pass TV signal through to TV-out when idling");
148 int zr36067_debug = 1;
149 module_param_named(debug, zr36067_debug, int, 0644);
150 MODULE_PARM_DESC(debug, "Debug level (0-5)");
152 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
153 MODULE_AUTHOR("Serguei Miridonov");
154 MODULE_LICENSE("GPL");
156 static struct pci_device_id zr36067_pci_tbl[] = {
157 {PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057,
158 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
161 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
163 int zoran_num; /* number of Buzs in use */
164 struct zoran zoran[BUZ_MAX];
166 /* videocodec bus functions ZR36060 */
168 zr36060_read (struct videocodec *codec,
171 struct zoran *zr = (struct zoran *) codec->master_data->data;
174 if (post_office_wait(zr)
175 || post_office_write(zr, 0, 1, reg >> 8)
176 || post_office_write(zr, 0, 2, reg & 0xff)) {
180 data = post_office_read(zr, 0, 3) & 0xff;
185 zr36060_write (struct videocodec *codec,
189 struct zoran *zr = (struct zoran *) codec->master_data->data;
191 if (post_office_wait(zr)
192 || post_office_write(zr, 0, 1, reg >> 8)
193 || post_office_write(zr, 0, 2, reg & 0xff)) {
197 post_office_write(zr, 0, 3, val & 0xff);
200 /* videocodec bus functions ZR36050 */
202 zr36050_read (struct videocodec *codec,
205 struct zoran *zr = (struct zoran *) codec->master_data->data;
208 if (post_office_wait(zr)
209 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
213 data = post_office_read(zr, 0, reg & 0x03) & 0xff; // reg. LOWBYTES + read
218 zr36050_write (struct videocodec *codec,
222 struct zoran *zr = (struct zoran *) codec->master_data->data;
224 if (post_office_wait(zr)
225 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
229 post_office_write(zr, 0, reg & 0x03, val & 0xff); // reg. LOWBYTES + wr. data
232 /* videocodec bus functions ZR36016 */
234 zr36016_read (struct videocodec *codec,
237 struct zoran *zr = (struct zoran *) codec->master_data->data;
240 if (post_office_wait(zr)) {
244 data = post_office_read(zr, 2, reg & 0x03) & 0xff; // read
248 /* hack for in zoran_device.c */
250 zr36016_write (struct videocodec *codec,
254 struct zoran *zr = (struct zoran *) codec->master_data->data;
256 if (post_office_wait(zr)) {
260 post_office_write(zr, 2, reg & 0x03, val & 0x0ff); // wr. data
264 * Board specific information
268 dc10_init (struct zoran *zr)
270 dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
272 /* Pixel clock selection */
275 /* Enable the video bus sync signals */
280 dc10plus_init (struct zoran *zr)
282 dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
286 buz_init (struct zoran *zr)
288 dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
290 /* some stuff from Iomega */
291 pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
292 pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
293 pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
297 lml33_init (struct zoran *zr)
299 dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
301 GPIO(zr, 2, 1); // Set Composite input/output
305 avs6eyes_init (struct zoran *zr)
307 // AverMedia 6-Eyes original driver by Christer Weinigel
309 // Lifted straight from Christer's old driver and
310 // modified slightly by Martin Samuelsson.
312 int mux = default_mux; /* 1 = BT866, 7 = VID1 */
314 GPIO(zr, 4, 1); /* Bt866 SLEEP on */
317 GPIO(zr, 0, 1); /* ZR36060 /RESET on */
318 GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
319 GPIO(zr, 2, mux & 1); /* MUX S0 */
320 GPIO(zr, 3, 0); /* /FRAME on */
321 GPIO(zr, 4, 0); /* Bt866 SLEEP off */
322 GPIO(zr, 5, mux & 2); /* MUX S1 */
323 GPIO(zr, 6, 0); /* ? */
324 GPIO(zr, 7, mux & 4); /* MUX S2 */
329 i2cid_to_modulename (u16 i2c_id)
334 case I2C_DRIVERID_SAA7110:
337 case I2C_DRIVERID_SAA7111A:
340 case I2C_DRIVERID_SAA7114:
343 case I2C_DRIVERID_SAA7185B:
346 case I2C_DRIVERID_ADV7170:
349 case I2C_DRIVERID_ADV7175:
352 case I2C_DRIVERID_BT819:
355 case I2C_DRIVERID_BT856:
358 case I2C_DRIVERID_VPX3220:
361 /* case I2C_DRIVERID_VPX3224:
364 case I2C_DRIVERID_MSE3000:
375 codecid_to_modulename (u16 codecid)
380 case CODEC_TYPE_ZR36060:
383 case CODEC_TYPE_ZR36050:
386 case CODEC_TYPE_ZR36016:
397 // u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
400 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
401 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
402 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
403 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
405 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
406 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
408 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
409 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
410 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
412 /* FIXME: I cannot swap U and V in saa7114, so i do one
413 * pixel left shift in zoran (75 -> 74)
414 * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
415 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
416 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
418 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
419 * copy Maxim's left shift hack for the 6 Eyes.
421 * Christer's driver used the unshifted norms, though...
423 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
424 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
426 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
430 .i2c_decoder = I2C_DRIVERID_VPX3220,
431 /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/
432 .video_codec = CODEC_TYPE_ZR36050,
433 .video_vfe = CODEC_TYPE_ZR36016,
439 { 0, "Internal/comp" }
448 .vsync_int = ZR36057_ISR_GIRQ1,
449 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
450 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
452 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
453 .gws_not_connected = 0,
459 .i2c_decoder = I2C_DRIVERID_SAA7110,
460 .i2c_encoder = I2C_DRIVERID_ADV7175,
461 .video_codec = CODEC_TYPE_ZR36060,
467 { 5, "Internal/comp" }
474 .jpeg_int = ZR36057_ISR_GIRQ0,
475 .vsync_int = ZR36057_ISR_GIRQ1,
476 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
477 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
479 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
480 .gws_not_connected = 0,
482 .init = &dc10plus_init,
486 .vendor_id = PCI_VENDOR_ID_MIRO,
487 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
488 .i2c_decoder = I2C_DRIVERID_SAA7110,
489 .i2c_encoder = I2C_DRIVERID_ADV7175,
490 .video_codec = CODEC_TYPE_ZR36060,
496 { 5, "Internal/comp" }
504 .jpeg_int = ZR36057_ISR_GIRQ0,
505 .vsync_int = ZR36057_ISR_GIRQ1,
506 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
507 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
509 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
510 .gws_not_connected = 0,
512 .init = &dc10plus_init,
516 .i2c_decoder = I2C_DRIVERID_VPX3220,
517 .i2c_encoder = I2C_DRIVERID_ADV7175,
518 .video_codec = CODEC_TYPE_ZR36050,
519 .video_vfe = CODEC_TYPE_ZR36016,
525 { 0, "Internal/comp" }
534 .vsync_int = ZR36057_ISR_GIRQ1,
535 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
536 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
538 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
539 .gws_not_connected = 0,
545 .vendor_id = PCI_VENDOR_ID_MIRO,
546 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
547 .i2c_decoder = I2C_DRIVERID_VPX3220,
548 .i2c_encoder = I2C_DRIVERID_ADV7175,
549 .video_codec = CODEC_TYPE_ZR36050,
550 .video_vfe = CODEC_TYPE_ZR36016,
556 { 0, "Internal/comp" }
565 .vsync_int = ZR36057_ISR_GIRQ1,
566 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
567 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
569 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
570 .gws_not_connected = 0,
576 .i2c_decoder = I2C_DRIVERID_BT819,
577 .i2c_encoder = I2C_DRIVERID_BT856,
578 .video_codec = CODEC_TYPE_ZR36060,
591 .jpeg_int = ZR36057_ISR_GIRQ1,
592 .vsync_int = ZR36057_ISR_GIRQ0,
593 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
594 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
596 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
597 .gws_not_connected = 1,
603 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
604 .device_id = PCI_DEVICE_ID_LML_33R10,
605 .i2c_decoder = I2C_DRIVERID_SAA7114,
606 .i2c_encoder = I2C_DRIVERID_ADV7170,
607 .video_codec = CODEC_TYPE_ZR36060,
620 .jpeg_int = ZR36057_ISR_GIRQ1,
621 .vsync_int = ZR36057_ISR_GIRQ0,
622 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
623 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
625 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
626 .gws_not_connected = 1,
632 .vendor_id = PCI_VENDOR_ID_IOMEGA,
633 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
634 .i2c_decoder = I2C_DRIVERID_SAA7111A,
635 .i2c_encoder = I2C_DRIVERID_SAA7185B,
636 .video_codec = CODEC_TYPE_ZR36060,
649 .jpeg_int = ZR36057_ISR_GIRQ1,
650 .vsync_int = ZR36057_ISR_GIRQ0,
651 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
652 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
654 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
655 .gws_not_connected = 1,
661 /* AverMedia chose not to brand the 6-Eyes. Thus it
662 can't be autodetected, and requires card=x. */
665 .i2c_decoder = I2C_DRIVERID_KS0127,
666 .i2c_encoder = I2C_DRIVERID_BT866,
667 .video_codec = CODEC_TYPE_ZR36060,
671 { 0, "Composite 1" },
672 { 1, "Composite 2" },
673 { 2, "Composite 3" },
674 { 4, "Composite 4" },
675 { 5, "Composite 5" },
676 { 6, "Composite 6" },
684 &f50ccir601_avs6eyes,
685 &f60ccir601_avs6eyes,
688 .jpeg_int = ZR36057_ISR_GIRQ1,
689 .vsync_int = ZR36057_ISR_GIRQ0,
690 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
691 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
692 .gpcs = { 3, 1 }, // Validity unknown /Sam
693 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam
694 .gws_not_connected = 1,
696 .init = &avs6eyes_init,
704 /* software I2C functions */
706 zoran_i2c_getsda (void *data)
708 struct zoran *zr = (struct zoran *) data;
710 return (btread(ZR36057_I2CBR) >> 1) & 1;
714 zoran_i2c_getscl (void *data)
716 struct zoran *zr = (struct zoran *) data;
718 return btread(ZR36057_I2CBR) & 1;
722 zoran_i2c_setsda (void *data,
725 struct zoran *zr = (struct zoran *) data;
731 btwrite(zr->i2cbr, ZR36057_I2CBR);
735 zoran_i2c_setscl (void *data,
738 struct zoran *zr = (struct zoran *) data;
744 btwrite(zr->i2cbr, ZR36057_I2CBR);
748 zoran_i2c_client_register (struct i2c_client *client)
750 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
754 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
755 ZR_DEVNAME(zr), client->driver->id);
757 mutex_lock(&zr->resource_lock);
760 /* we're already busy, so we keep a reference to
761 * them... Could do a lot of stuff here, but this
762 * is easiest. (Did I ever mention I'm a lazy ass?)
765 goto clientreg_unlock_and_return;
768 if (client->driver->id == zr->card.i2c_decoder)
769 zr->decoder = client;
770 else if (client->driver->id == zr->card.i2c_encoder)
771 zr->encoder = client;
774 goto clientreg_unlock_and_return;
777 clientreg_unlock_and_return:
778 mutex_unlock(&zr->resource_lock);
784 zoran_i2c_client_unregister (struct i2c_client *client)
786 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
789 dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
791 mutex_lock(&zr->resource_lock);
795 goto clientunreg_unlock_and_return;
798 /* try to locate it */
799 if (client == zr->encoder) {
801 } else if (client == zr->decoder) {
803 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
805 clientunreg_unlock_and_return:
806 mutex_unlock(&zr->resource_lock);
810 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
811 .setsda = zoran_i2c_setsda,
812 .setscl = zoran_i2c_setscl,
813 .getsda = zoran_i2c_getsda,
814 .getscl = zoran_i2c_getscl,
820 zoran_register_i2c (struct zoran *zr)
822 memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
823 sizeof(struct i2c_algo_bit_data));
824 zr->i2c_algo.data = zr;
825 zr->i2c_adapter.id = I2C_HW_B_ZR36067;
826 zr->i2c_adapter.client_register = zoran_i2c_client_register;
827 zr->i2c_adapter.client_unregister = zoran_i2c_client_unregister;
828 strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
829 sizeof(zr->i2c_adapter.name));
830 i2c_set_adapdata(&zr->i2c_adapter, zr);
831 zr->i2c_adapter.algo_data = &zr->i2c_algo;
832 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
833 return i2c_bit_add_bus(&zr->i2c_adapter);
837 zoran_unregister_i2c (struct zoran *zr)
839 i2c_del_adapter(&zr->i2c_adapter);
842 /* Check a zoran_params struct for correctness, insert default params */
845 zoran_check_jpg_settings (struct zoran *zr,
846 struct zoran_jpg_settings *settings)
848 int err = 0, err0 = 0;
852 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
853 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
854 settings->VerDcm, settings->TmpDcm);
857 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
858 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
859 settings->img_width, settings->img_height);
860 /* Check decimation, set default values for decimation = 1, 2, 4 */
861 switch (settings->decimation) {
864 settings->HorDcm = 1;
865 settings->VerDcm = 1;
866 settings->TmpDcm = 1;
867 settings->field_per_buff = 2;
870 settings->img_width = BUZ_MAX_WIDTH;
871 settings->img_height = BUZ_MAX_HEIGHT / 2;
875 settings->HorDcm = 2;
876 settings->VerDcm = 1;
877 settings->TmpDcm = 2;
878 settings->field_per_buff = 1;
879 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
881 settings->img_width =
882 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
883 settings->img_height = BUZ_MAX_HEIGHT / 2;
887 if (zr->card.type == DC10_new) {
890 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
896 settings->HorDcm = 4;
897 settings->VerDcm = 2;
898 settings->TmpDcm = 2;
899 settings->field_per_buff = 1;
900 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
902 settings->img_width =
903 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
904 settings->img_height = BUZ_MAX_HEIGHT / 2;
908 /* We have to check the data the user has set */
910 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
911 (zr->card.type == DC10_new || settings->HorDcm != 4))
913 if (settings->VerDcm != 1 && settings->VerDcm != 2)
915 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
917 if (settings->field_per_buff != 1 &&
918 settings->field_per_buff != 2)
920 if (settings->img_x < 0)
922 if (settings->img_y < 0)
924 if (settings->img_width < 0)
926 if (settings->img_height < 0)
928 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
930 if (settings->img_y + settings->img_height >
933 if (settings->HorDcm && settings->VerDcm) {
934 if (settings->img_width %
935 (16 * settings->HorDcm) != 0)
937 if (settings->img_height %
938 (8 * settings->VerDcm) != 0)
945 "%s: check_jpg_settings() - error in params for decimation = 0\n",
953 "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
954 ZR_DEVNAME(zr), settings->decimation);
959 if (settings->jpg_comp.quality > 100)
960 settings->jpg_comp.quality = 100;
961 if (settings->jpg_comp.quality < 5)
962 settings->jpg_comp.quality = 5;
963 if (settings->jpg_comp.APPn < 0)
964 settings->jpg_comp.APPn = 0;
965 if (settings->jpg_comp.APPn > 15)
966 settings->jpg_comp.APPn = 15;
967 if (settings->jpg_comp.APP_len < 0)
968 settings->jpg_comp.APP_len = 0;
969 if (settings->jpg_comp.APP_len > 60)
970 settings->jpg_comp.APP_len = 60;
971 if (settings->jpg_comp.COM_len < 0)
972 settings->jpg_comp.COM_len = 0;
973 if (settings->jpg_comp.COM_len > 60)
974 settings->jpg_comp.COM_len = 60;
981 zoran_open_init_params (struct zoran *zr)
985 /* User must explicitly set a window */
986 zr->overlay_settings.is_set = 0;
987 zr->overlay_mask = NULL;
988 zr->overlay_active = ZORAN_FREE;
990 zr->v4l_memgrab_active = 0;
991 zr->v4l_overlay_active = 0;
992 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
993 zr->v4l_grab_seq = 0;
994 zr->v4l_settings.width = 192;
995 zr->v4l_settings.height = 144;
996 zr->v4l_settings.format = &zoran_formats[4]; /* YUY2 - YUV-4:2:2 packed */
997 zr->v4l_settings.bytesperline =
998 zr->v4l_settings.width *
999 ((zr->v4l_settings.format->depth + 7) / 8);
1001 /* DMA ring stuff for V4L */
1002 zr->v4l_pend_tail = 0;
1003 zr->v4l_pend_head = 0;
1004 zr->v4l_sync_tail = 0;
1005 zr->v4l_buffers.active = ZORAN_FREE;
1006 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1007 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1009 zr->v4l_buffers.allocated = 0;
1011 for (i = 0; i < BUZ_MAX_FRAME; i++) {
1012 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1014 zr->jpg_buffers.active = ZORAN_FREE;
1015 zr->jpg_buffers.allocated = 0;
1016 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1017 zr->jpg_settings.decimation = 1;
1018 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1019 if (zr->card.type != BUZ)
1020 zr->jpg_settings.odd_even = 1;
1022 zr->jpg_settings.odd_even = 0;
1023 zr->jpg_settings.jpg_comp.APPn = 0;
1024 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
1025 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1026 sizeof(zr->jpg_settings.jpg_comp.APP_data));
1027 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
1028 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1029 sizeof(zr->jpg_settings.jpg_comp.COM_data));
1030 zr->jpg_settings.jpg_comp.jpeg_markers =
1031 JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1032 i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1036 "%s: zoran_open_init_params() internal error\n",
1039 clear_interrupt_counters(zr);
1043 static void __devinit
1044 test_interrupts (struct zoran *zr)
1049 clear_interrupt_counters(zr);
1052 icr = btread(ZR36057_ICR);
1053 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1054 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1055 timeout = schedule_timeout(HZ);
1056 finish_wait(&zr->test_q, &wait);
1057 btwrite(0, ZR36057_ICR);
1058 btwrite(0x78000000, ZR36057_ISR);
1060 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1062 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1064 if (zr36067_debug > 1)
1065 print_interrupts(zr);
1066 btwrite(icr, ZR36057_ICR);
1069 static int __devinit
1070 zr36057_init (struct zoran *zr)
1078 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1079 ZR_DEVNAME(zr), zr->id, zr);
1081 /* default setup of all parameters which will persist between opens */
1084 init_waitqueue_head(&zr->v4l_capq);
1085 init_waitqueue_head(&zr->jpg_capq);
1086 init_waitqueue_head(&zr->test_q);
1087 zr->jpg_buffers.allocated = 0;
1088 zr->v4l_buffers.allocated = 0;
1090 zr->buffer.base = (void *) vidmem;
1091 zr->buffer.width = 0;
1092 zr->buffer.height = 0;
1093 zr->buffer.depth = 0;
1094 zr->buffer.bytesperline = 0;
1096 /* Avoid nonsense settings from user for default input/norm */
1097 if (default_norm < VIDEO_MODE_PAL &&
1098 default_norm > VIDEO_MODE_SECAM)
1099 default_norm = VIDEO_MODE_PAL;
1100 zr->norm = default_norm;
1101 if (!(zr->timing = zr->card.tvn[zr->norm])) {
1104 "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1106 zr->norm = VIDEO_MODE_PAL;
1107 zr->timing = zr->card.tvn[zr->norm];
1110 if (default_input > zr->card.inputs-1) {
1113 "%s: default_input value %d out of range (0-%d)\n",
1114 ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1117 zr->input = default_input;
1119 /* Should the following be reset at every open ? */
1121 zr->contrast = 32768;
1122 zr->saturation = 32768;
1123 zr->brightness = 32768;
1125 /* default setup (will be repeated at every open) */
1126 zoran_open_init_params(zr);
1128 /* allocate memory *before* doing anything to the hardware
1129 * in case allocation fails */
1130 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1131 zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1132 if (!zr->stat_com || !zr->video_dev) {
1135 "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1140 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1141 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1145 * Now add the template and register the device unit.
1147 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1148 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1149 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1151 goto exit_unregister;
1153 zoran_init_hardware(zr);
1154 if (zr36067_debug > 2)
1155 detect_guest_activity(zr);
1156 test_interrupts(zr);
1157 if (!pass_through) {
1158 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1159 encoder_command(zr, ENCODER_SET_INPUT, &two);
1162 zr->zoran_proc = NULL;
1163 zr->initialized = 1;
1167 zoran_unregister_i2c(zr);
1169 kfree(zr->stat_com);
1170 kfree(zr->video_dev);
1175 zoran_release (struct zoran *zr)
1177 if (!zr->initialized)
1179 /* unregister videocodec bus */
1181 struct videocodec_master *master = zr->codec->master_data;
1183 videocodec_detach(zr->codec);
1187 struct videocodec_master *master = zr->vfe->master_data;
1189 videocodec_detach(zr->vfe);
1193 /* unregister i2c bus */
1194 zoran_unregister_i2c(zr);
1195 /* disable PCI bus-mastering */
1196 zoran_set_pci_master(zr, 0);
1197 /* put chip into reset */
1198 btwrite(0, ZR36057_SPGPPCR);
1199 free_irq(zr->pci_dev->irq, zr);
1200 /* unmap and free memory */
1201 kfree(zr->stat_com);
1202 zoran_proc_cleanup(zr);
1203 iounmap(zr->zr36057_mem);
1204 pci_disable_device(zr->pci_dev);
1205 video_unregister_device(zr->video_dev);
1209 zoran_vdev_release (struct video_device *vdev)
1214 static struct videocodec_master * __devinit
1215 zoran_setup_videocodec (struct zoran *zr,
1218 struct videocodec_master *m = NULL;
1220 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1224 "%s: zoran_setup_videocodec() - no memory\n",
1229 /* magic and type are unused for master struct. Makes sense only at
1231 In the past, .type were initialized to the old V4L1 .hardware
1232 value, as VID_HARDWARE_ZR36067
1237 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1238 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1243 case CODEC_TYPE_ZR36060:
1244 m->readreg = zr36060_read;
1245 m->writereg = zr36060_write;
1246 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1248 case CODEC_TYPE_ZR36050:
1249 m->readreg = zr36050_read;
1250 m->writereg = zr36050_write;
1251 m->flags |= CODEC_FLAG_JPEG;
1253 case CODEC_TYPE_ZR36016:
1254 m->readreg = zr36016_read;
1255 m->writereg = zr36016_write;
1256 m->flags |= CODEC_FLAG_VFE;
1264 * Scan for a Buz card (actually for the PCI controller ZR36057),
1265 * request the irq and map the io memory
1267 static int __devinit
1270 unsigned char latency, need_latency;
1272 struct pci_dev *dev = NULL;
1274 struct videocodec_master *master_vfe = NULL;
1275 struct videocodec_master *master_codec = NULL;
1277 char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1280 while (zoran_num < BUZ_MAX &&
1281 (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1282 card_num = card[zoran_num];
1283 zr = &zoran[zoran_num];
1284 memset(zr, 0, sizeof(struct zoran)); // Just in case if previous cycle failed
1286 //zr->zr36057_mem = NULL;
1288 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1289 spin_lock_init(&zr->spinlock);
1290 mutex_init(&zr->resource_lock);
1291 if (pci_enable_device(dev))
1293 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1294 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1296 if (zr->revision < 2) {
1299 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1300 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1303 if (card_num == -1) {
1306 "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1312 unsigned short ss_vendor, ss_device;
1314 ss_vendor = zr->pci_dev->subsystem_vendor;
1315 ss_device = zr->pci_dev->subsystem_device;
1318 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1319 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1323 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1324 ZR_DEVNAME(zr), ss_vendor, ss_device);
1325 if (card_num == -1) {
1328 "%s: find_zr36057() - trying to autodetect card type\n",
1330 for (i=0;i<NUM_CARDS;i++) {
1331 if (ss_vendor == zoran_cards[i].vendor_id &&
1332 ss_device == zoran_cards[i].device_id) {
1335 "%s: find_zr36057() - card %s detected\n",
1337 zoran_cards[i].name);
1342 if (i == NUM_CARDS) {
1345 "%s: find_zr36057() - unknown card\n",
1352 if (card_num < 0 || card_num >= NUM_CARDS) {
1355 "%s: find_zr36057() - invalid cardnum %d\n",
1356 ZR_DEVNAME(zr), card_num);
1360 /* even though we make this a non pointer and thus
1361 * theoretically allow for making changes to this struct
1362 * on a per-individual card basis at runtime, this is
1363 * strongly discouraged. This structure is intended to
1364 * keep general card information, no settings or anything */
1365 zr->card = zoran_cards[card_num];
1366 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1367 "%s[%u]", zr->card.name, zr->id);
1369 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1370 if (!zr->zr36057_mem) {
1373 "%s: find_zr36057() - ioremap failed\n",
1378 result = request_irq(zr->pci_dev->irq,
1380 IRQF_SHARED | IRQF_DISABLED,
1384 if (result == -EINVAL) {
1387 "%s: find_zr36057() - bad irq number or handler\n",
1389 } else if (result == -EBUSY) {
1392 "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1393 ZR_DEVNAME(zr), zr->pci_dev->irq);
1397 "%s: find_zr36057() - can't assign irq, error code %d\n",
1398 ZR_DEVNAME(zr), result);
1403 /* set PCI latency timer */
1404 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1406 need_latency = zr->revision > 1 ? 32 : 48;
1407 if (latency != need_latency) {
1410 "%s: Changing PCI latency from %d to %d.\n",
1411 ZR_DEVNAME(zr), latency, need_latency);
1412 pci_write_config_byte(zr->pci_dev,
1417 zr36057_restart(zr);
1419 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1423 if (decoder[zr->id] != -1) {
1424 i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1425 zr->card.i2c_decoder = decoder[zr->id];
1426 } else if (zr->card.i2c_decoder != 0) {
1428 i2cid_to_modulename(zr->card.i2c_decoder);
1430 i2c_dec_name = NULL;
1434 if ((result = request_module(i2c_dec_name)) < 0) {
1437 "%s: failed to load module %s: %d\n",
1438 ZR_DEVNAME(zr), i2c_dec_name, result);
1443 if (encoder[zr->id] != -1) {
1444 i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1445 zr->card.i2c_encoder = encoder[zr->id];
1446 } else if (zr->card.i2c_encoder != 0) {
1448 i2cid_to_modulename(zr->card.i2c_encoder);
1450 i2c_enc_name = NULL;
1454 if ((result = request_module(i2c_enc_name)) < 0) {
1457 "%s: failed to load module %s: %d\n",
1458 ZR_DEVNAME(zr), i2c_enc_name, result);
1462 if (zoran_register_i2c(zr) < 0) {
1465 "%s: find_zr36057() - can't initialize i2c bus\n",
1471 KERN_INFO "%s: Initializing videocodec bus...\n",
1474 if (zr->card.video_codec != 0 &&
1476 codecid_to_modulename(zr->card.video_codec)) != NULL) {
1477 if ((result = request_module(codec_name)) < 0) {
1480 "%s: failed to load modules %s: %d\n",
1481 ZR_DEVNAME(zr), codec_name, result);
1484 if (zr->card.video_vfe != 0 &&
1486 codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1487 if ((result = request_module(vfe_name)) < 0) {
1490 "%s: failed to load modules %s: %d\n",
1491 ZR_DEVNAME(zr), vfe_name, result);
1495 /* reset JPEG codec */
1496 jpeg_codec_sleep(zr, 1);
1497 jpeg_codec_reset(zr);
1498 /* video bus enabled */
1499 /* display codec revision */
1500 if (zr->card.video_codec != 0) {
1501 master_codec = zoran_setup_videocodec(zr,
1502 zr->card.video_codec);
1505 zr->codec = videocodec_attach(master_codec);
1509 "%s: find_zr36057() - no codec found\n",
1513 if (zr->codec->type != zr->card.video_codec) {
1516 "%s: find_zr36057() - wrong codec\n",
1518 goto zr_detach_codec;
1521 if (zr->card.video_vfe != 0) {
1522 master_vfe = zoran_setup_videocodec(zr,
1523 zr->card.video_vfe);
1525 goto zr_detach_codec;
1526 zr->vfe = videocodec_attach(master_vfe);
1530 "%s: find_zr36057() - no VFE found\n",
1534 if (zr->vfe->type != zr->card.video_vfe) {
1537 "%s: find_zr36057() = wrong VFE\n",
1542 /* Success so keep the pci_dev referenced */
1543 pci_dev_get(zr->pci_dev);
1549 videocodec_detach(zr->vfe);
1553 videocodec_detach(zr->codec);
1555 kfree(master_codec);
1557 zoran_unregister_i2c(zr);
1559 btwrite(0, ZR36057_SPGPPCR);
1560 free_irq(zr->pci_dev->irq, zr);
1562 iounmap(zr->zr36057_mem);
1565 if (dev) /* Clean up ref count on early exit */
1568 if (zoran_num == 0) {
1569 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1575 init_dc10_cards (void)
1579 memset(zoran, 0, sizeof(zoran));
1580 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1581 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1583 /* Look for cards */
1584 if (find_zr36057() < 0) {
1589 dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1591 /* check the parameters we have been given, adjust if necessary */
1594 if (v4l_nbufs > VIDEO_MAX_FRAME)
1595 v4l_nbufs = VIDEO_MAX_FRAME;
1596 /* The user specfies the in KB, we want them in byte
1597 * (and page aligned) */
1598 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1599 if (v4l_bufsize < 32768)
1600 v4l_bufsize = 32768;
1601 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1602 if (v4l_bufsize > 2048 * 1024)
1603 v4l_bufsize = 2048 * 1024;
1606 if (jpg_nbufs > BUZ_MAX_FRAME)
1607 jpg_nbufs = BUZ_MAX_FRAME;
1608 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1609 if (jpg_bufsize < 8192)
1611 if (jpg_bufsize > (512 * 1024))
1612 jpg_bufsize = 512 * 1024;
1613 /* Use parameter for vidmem or try to find a video card */
1617 "%s: Using supplied video memory base address @ 0x%lx\n",
1618 ZORAN_NAME, vidmem);
1621 /* random nonsense */
1622 dprintk(6, KERN_DEBUG "Jotti is een held!\n");
1624 /* some mainboards might not do PCI-PCI data transfer well */
1625 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1628 "%s: chipset does not support reliable PCI-PCI DMA\n",
1632 /* take care of Natoma chipset and a revision 1 zr36057 */
1633 for (i = 0; i < zoran_num; i++) {
1634 struct zoran *zr = &zoran[i];
1636 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1637 zr->jpg_buffers.need_contiguous = 1;
1640 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1644 if (zr36057_init(zr) < 0) {
1645 for (i = 0; i < zoran_num; i++)
1646 zoran_release(&zoran[i]);
1649 zoran_proc_init(zr);
1656 unload_dc10_cards (void)
1660 for (i = 0; i < zoran_num; i++)
1661 zoran_release(&zoran[i]);
1664 module_init(init_dc10_cards);
1665 module_exit(unload_dc10_cards);