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/config.h>
31 #include <linux/types.h>
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/vmalloc.h>
37 #include <linux/proc_fs.h>
38 #include <linux/i2c.h>
39 #include <linux/i2c-algo-bit.h>
40 #include <linux/videodev.h>
41 #include <linux/spinlock.h>
42 #include <linux/sem.h>
43 #include <linux/kmod.h>
44 #include <linux/wait.h>
46 #include <linux/pci.h>
47 #include <linux/interrupt.h>
48 #include <linux/video_decoder.h>
49 #include <linux/video_encoder.h>
53 #include "videocodec.h"
55 #include "zoran_card.h"
56 #include "zoran_device.h"
57 #include "zoran_procfs.h"
59 #define I2C_NAME(x) (x)->name
61 extern const struct zoran_format zoran_formats[];
63 static int card[BUZ_MAX] = { -1, -1, -1, -1 };
64 module_param_array(card, int, NULL, 0);
65 MODULE_PARM_DESC(card, "The type of card");
67 static int encoder[BUZ_MAX] = { -1, -1, -1, -1 };
68 module_param_array(encoder, int, NULL, 0);
69 MODULE_PARM_DESC(encoder, "i2c TV encoder");
71 static int decoder[BUZ_MAX] = { -1, -1, -1, -1 };
72 module_param_array(decoder, int, NULL, 0);
73 MODULE_PARM_DESC(decoder, "i2c TV decoder");
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 = 0; /* Video memory base address */
84 module_param(vidmem, ulong, 0);
87 Default input and video norm at startup of the driver.
90 static int default_input = 0; /* 0=Composite, 1=S-Video */
91 module_param(default_input, int, 0);
92 MODULE_PARM_DESC(default_input,
93 "Default input (0=Composite, 1=S-Video, 2=Internal)");
95 static int default_norm = 0; /* 0=PAL, 1=NTSC 2=SECAM */
96 module_param(default_norm, int, 0);
97 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
99 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
100 module_param(video_nr, int, 0);
101 MODULE_PARM_DESC(video_nr, "video device number");
104 Number and size of grab buffers for Video 4 Linux
105 The vast majority of applications should not need more than 2,
106 the very popular BTTV driver actually does ONLY have 2.
107 Time sensitive applications might need more, the maximum
108 is VIDEO_MAX_FRAME (defined in <linux/videodev.h>).
110 The size is set so that the maximum possible request
111 can be satisfied. Decrease it, if bigphys_area alloc'd
112 memory is low. If you don't have the bigphys_area patch,
113 set it to 128 KB. Will you allow only to grab small
114 images with V4L, but that's better than nothing.
116 v4l_bufsize has to be given in KB !
121 int v4l_bufsize = 128; /* Everybody should be able to work with this setting */
122 module_param(v4l_nbufs, int, 0);
123 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
124 module_param(v4l_bufsize, int, 0);
125 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
128 int jpg_bufsize = 512; /* max size for 100% quality full-PAL frame */
129 module_param(jpg_nbufs, int, 0);
130 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
131 module_param(jpg_bufsize, int, 0);
132 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
134 int pass_through = 0; /* 1=Pass through TV signal when device is not used */
135 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
136 module_param(pass_through, int, 0);
137 MODULE_PARM_DESC(pass_through,
138 "Pass TV signal through to TV-out when idling");
140 static int debug = 1;
141 int *zr_debug = &debug;
142 module_param(debug, int, 0);
143 MODULE_PARM_DESC(debug, "Debug level (0-4)");
145 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
146 MODULE_AUTHOR("Serguei Miridonov");
147 MODULE_LICENSE("GPL");
149 static struct pci_device_id zr36067_pci_tbl[] = {
150 {PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057,
151 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
154 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
156 #define dprintk(num, format, args...) \
158 if (*zr_debug >= num) \
159 printk(format, ##args); \
162 int zoran_num; /* number of Buzs in use */
163 struct zoran zoran[BUZ_MAX];
165 /* videocodec bus functions ZR36060 */
167 zr36060_read (struct videocodec *codec,
170 struct zoran *zr = (struct zoran *) codec->master_data->data;
173 if (post_office_wait(zr)
174 || post_office_write(zr, 0, 1, reg >> 8)
175 || post_office_write(zr, 0, 2, reg & 0xff)) {
179 data = post_office_read(zr, 0, 3) & 0xff;
184 zr36060_write (struct videocodec *codec,
188 struct zoran *zr = (struct zoran *) codec->master_data->data;
190 if (post_office_wait(zr)
191 || post_office_write(zr, 0, 1, reg >> 8)
192 || post_office_write(zr, 0, 2, reg & 0xff)) {
196 post_office_write(zr, 0, 3, val & 0xff);
199 /* videocodec bus functions ZR36050 */
201 zr36050_read (struct videocodec *codec,
204 struct zoran *zr = (struct zoran *) codec->master_data->data;
207 if (post_office_wait(zr)
208 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
212 data = post_office_read(zr, 0, reg & 0x03) & 0xff; // reg. LOWBYTES + read
217 zr36050_write (struct videocodec *codec,
221 struct zoran *zr = (struct zoran *) codec->master_data->data;
223 if (post_office_wait(zr)
224 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
228 post_office_write(zr, 0, reg & 0x03, val & 0xff); // reg. LOWBYTES + wr. data
231 /* videocodec bus functions ZR36016 */
233 zr36016_read (struct videocodec *codec,
236 struct zoran *zr = (struct zoran *) codec->master_data->data;
239 if (post_office_wait(zr)) {
243 data = post_office_read(zr, 2, reg & 0x03) & 0xff; // read
247 /* hack for in zoran_device.c */
249 zr36016_write (struct videocodec *codec,
253 struct zoran *zr = (struct zoran *) codec->master_data->data;
255 if (post_office_wait(zr)) {
259 post_office_write(zr, 2, reg & 0x03, val & 0x0ff); // wr. data
263 * Board specific information
267 dc10_init (struct zoran *zr)
269 dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
271 /* Pixel clock selection */
274 /* Enable the video bus sync signals */
279 dc10plus_init (struct zoran *zr)
281 dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
285 buz_init (struct zoran *zr)
287 dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
289 /* some stuff from Iomega */
290 pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
291 pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
292 pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
296 lml33_init (struct zoran *zr)
298 dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
300 GPIO(zr, 2, 1); // Set Composite input/output
304 i2cid_to_modulename (u16 i2c_id)
309 case I2C_DRIVERID_SAA7110:
312 case I2C_DRIVERID_SAA7111A:
315 case I2C_DRIVERID_SAA7114:
318 case I2C_DRIVERID_SAA7185B:
321 case I2C_DRIVERID_ADV7170:
324 case I2C_DRIVERID_ADV7175:
327 case I2C_DRIVERID_BT819:
330 case I2C_DRIVERID_BT856:
333 case I2C_DRIVERID_VPX3220:
336 /* case I2C_DRIVERID_VPX3224:
339 case I2C_DRIVERID_MSE3000:
350 codecid_to_modulename (u16 codecid)
355 case CODEC_TYPE_ZR36060:
358 case CODEC_TYPE_ZR36050:
361 case CODEC_TYPE_ZR36016:
372 // u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
375 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
376 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
377 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
378 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
380 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
381 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
383 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
384 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
385 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
387 /* FIXME: I cannot swap U and V in saa7114, so i do one
388 * pixel left shift in zoran (75 -> 74)
389 * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
390 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
391 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
393 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
397 .i2c_decoder = I2C_DRIVERID_VPX3220,
398 /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/
399 .video_codec = CODEC_TYPE_ZR36050,
400 .video_vfe = CODEC_TYPE_ZR36016,
406 { 0, "Internal/comp" }
415 .vsync_int = ZR36057_ISR_GIRQ1,
416 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
417 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
419 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
420 .gws_not_connected = 0,
425 .i2c_decoder = I2C_DRIVERID_SAA7110,
426 .i2c_encoder = I2C_DRIVERID_ADV7175,
427 .video_codec = CODEC_TYPE_ZR36060,
433 { 5, "Internal/comp" }
440 .jpeg_int = ZR36057_ISR_GIRQ0,
441 .vsync_int = ZR36057_ISR_GIRQ1,
442 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
443 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
445 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
446 .gws_not_connected = 0,
447 .init = &dc10plus_init,
451 .vendor_id = PCI_VENDOR_ID_MIRO,
452 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
453 .i2c_decoder = I2C_DRIVERID_SAA7110,
454 .i2c_encoder = I2C_DRIVERID_ADV7175,
455 .video_codec = CODEC_TYPE_ZR36060,
461 { 5, "Internal/comp" }
469 .jpeg_int = ZR36057_ISR_GIRQ0,
470 .vsync_int = ZR36057_ISR_GIRQ1,
471 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
472 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
474 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
475 .gws_not_connected = 0,
476 .init = &dc10plus_init,
480 .i2c_decoder = I2C_DRIVERID_VPX3220,
481 .i2c_encoder = I2C_DRIVERID_ADV7175,
482 .video_codec = CODEC_TYPE_ZR36050,
483 .video_vfe = CODEC_TYPE_ZR36016,
489 { 0, "Internal/comp" }
498 .vsync_int = ZR36057_ISR_GIRQ1,
499 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
500 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
502 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
503 .gws_not_connected = 0,
508 .vendor_id = PCI_VENDOR_ID_MIRO,
509 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
510 .i2c_decoder = I2C_DRIVERID_VPX3220,
511 .i2c_encoder = I2C_DRIVERID_ADV7175,
512 .video_codec = CODEC_TYPE_ZR36050,
513 .video_vfe = CODEC_TYPE_ZR36016,
519 { 0, "Internal/comp" }
528 .vsync_int = ZR36057_ISR_GIRQ1,
529 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
530 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
532 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
533 .gws_not_connected = 0,
538 .i2c_decoder = I2C_DRIVERID_BT819,
539 .i2c_encoder = I2C_DRIVERID_BT856,
540 .video_codec = CODEC_TYPE_ZR36060,
553 .jpeg_int = ZR36057_ISR_GIRQ1,
554 .vsync_int = ZR36057_ISR_GIRQ0,
555 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
556 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
558 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
559 .gws_not_connected = 1,
564 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
565 .device_id = PCI_DEVICE_ID_LML_33R10,
566 .i2c_decoder = I2C_DRIVERID_SAA7114,
567 .i2c_encoder = I2C_DRIVERID_ADV7170,
568 .video_codec = CODEC_TYPE_ZR36060,
581 .jpeg_int = ZR36057_ISR_GIRQ1,
582 .vsync_int = ZR36057_ISR_GIRQ0,
583 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
584 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
586 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
587 .gws_not_connected = 1,
592 .vendor_id = PCI_VENDOR_ID_IOMEGA,
593 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
594 .i2c_decoder = I2C_DRIVERID_SAA7111A,
595 .i2c_encoder = I2C_DRIVERID_SAA7185B,
596 .video_codec = CODEC_TYPE_ZR36060,
609 .jpeg_int = ZR36057_ISR_GIRQ1,
610 .vsync_int = ZR36057_ISR_GIRQ0,
611 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
612 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
614 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
615 .gws_not_connected = 1,
623 /* software I2C functions */
625 zoran_i2c_getsda (void *data)
627 struct zoran *zr = (struct zoran *) data;
629 return (btread(ZR36057_I2CBR) >> 1) & 1;
633 zoran_i2c_getscl (void *data)
635 struct zoran *zr = (struct zoran *) data;
637 return btread(ZR36057_I2CBR) & 1;
641 zoran_i2c_setsda (void *data,
644 struct zoran *zr = (struct zoran *) data;
650 btwrite(zr->i2cbr, ZR36057_I2CBR);
654 zoran_i2c_setscl (void *data,
657 struct zoran *zr = (struct zoran *) data;
663 btwrite(zr->i2cbr, ZR36057_I2CBR);
667 zoran_i2c_client_register (struct i2c_client *client)
669 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
673 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
674 ZR_DEVNAME(zr), client->driver->id);
676 down(&zr->resource_lock);
679 /* we're already busy, so we keep a reference to
680 * them... Could do a lot of stuff here, but this
681 * is easiest. (Did I ever mention I'm a lazy ass?)
684 goto clientreg_unlock_and_return;
687 if (client->driver->id == zr->card.i2c_decoder)
688 zr->decoder = client;
689 else if (client->driver->id == zr->card.i2c_encoder)
690 zr->encoder = client;
693 goto clientreg_unlock_and_return;
696 clientreg_unlock_and_return:
697 up(&zr->resource_lock);
703 zoran_i2c_client_unregister (struct i2c_client *client)
705 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
708 dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
710 down(&zr->resource_lock);
714 goto clientunreg_unlock_and_return;
717 /* try to locate it */
718 if (client == zr->encoder) {
720 } else if (client == zr->decoder) {
722 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
724 clientunreg_unlock_and_return:
725 up(&zr->resource_lock);
729 static struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
730 .setsda = zoran_i2c_setsda,
731 .setscl = zoran_i2c_setscl,
732 .getsda = zoran_i2c_getsda,
733 .getscl = zoran_i2c_getscl,
739 static struct i2c_adapter zoran_i2c_adapter_template = {
741 .id = I2C_HW_B_ZR36067,
743 .client_register = zoran_i2c_client_register,
744 .client_unregister = zoran_i2c_client_unregister,
748 zoran_register_i2c (struct zoran *zr)
750 memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
751 sizeof(struct i2c_algo_bit_data));
752 zr->i2c_algo.data = zr;
753 memcpy(&zr->i2c_adapter, &zoran_i2c_adapter_template,
754 sizeof(struct i2c_adapter));
755 strncpy(I2C_NAME(&zr->i2c_adapter), ZR_DEVNAME(zr),
756 sizeof(I2C_NAME(&zr->i2c_adapter)) - 1);
757 i2c_set_adapdata(&zr->i2c_adapter, zr);
758 zr->i2c_adapter.algo_data = &zr->i2c_algo;
759 return i2c_bit_add_bus(&zr->i2c_adapter);
763 zoran_unregister_i2c (struct zoran *zr)
765 i2c_bit_del_bus((&zr->i2c_adapter));
768 /* Check a zoran_params struct for correctness, insert default params */
771 zoran_check_jpg_settings (struct zoran *zr,
772 struct zoran_jpg_settings *settings)
774 int err = 0, err0 = 0;
778 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
779 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
780 settings->VerDcm, settings->TmpDcm);
783 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
784 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
785 settings->img_width, settings->img_height);
786 /* Check decimation, set default values for decimation = 1, 2, 4 */
787 switch (settings->decimation) {
790 settings->HorDcm = 1;
791 settings->VerDcm = 1;
792 settings->TmpDcm = 1;
793 settings->field_per_buff = 2;
796 settings->img_width = BUZ_MAX_WIDTH;
797 settings->img_height = BUZ_MAX_HEIGHT / 2;
801 settings->HorDcm = 2;
802 settings->VerDcm = 1;
803 settings->TmpDcm = 2;
804 settings->field_per_buff = 1;
805 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
807 settings->img_width =
808 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
809 settings->img_height = BUZ_MAX_HEIGHT / 2;
813 if (zr->card.type == DC10_new) {
816 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
822 settings->HorDcm = 4;
823 settings->VerDcm = 2;
824 settings->TmpDcm = 2;
825 settings->field_per_buff = 1;
826 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
828 settings->img_width =
829 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
830 settings->img_height = BUZ_MAX_HEIGHT / 2;
834 /* We have to check the data the user has set */
836 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
837 (zr->card.type == DC10_new || settings->HorDcm != 4))
839 if (settings->VerDcm != 1 && settings->VerDcm != 2)
841 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
843 if (settings->field_per_buff != 1 &&
844 settings->field_per_buff != 2)
846 if (settings->img_x < 0)
848 if (settings->img_y < 0)
850 if (settings->img_width < 0)
852 if (settings->img_height < 0)
854 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
856 if (settings->img_y + settings->img_height >
859 if (settings->HorDcm && settings->VerDcm) {
860 if (settings->img_width %
861 (16 * settings->HorDcm) != 0)
863 if (settings->img_height %
864 (8 * settings->VerDcm) != 0)
871 "%s: check_jpg_settings() - error in params for decimation = 0\n",
879 "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
880 ZR_DEVNAME(zr), settings->decimation);
885 if (settings->jpg_comp.quality > 100)
886 settings->jpg_comp.quality = 100;
887 if (settings->jpg_comp.quality < 5)
888 settings->jpg_comp.quality = 5;
889 if (settings->jpg_comp.APPn < 0)
890 settings->jpg_comp.APPn = 0;
891 if (settings->jpg_comp.APPn > 15)
892 settings->jpg_comp.APPn = 15;
893 if (settings->jpg_comp.APP_len < 0)
894 settings->jpg_comp.APP_len = 0;
895 if (settings->jpg_comp.APP_len > 60)
896 settings->jpg_comp.APP_len = 60;
897 if (settings->jpg_comp.COM_len < 0)
898 settings->jpg_comp.COM_len = 0;
899 if (settings->jpg_comp.COM_len > 60)
900 settings->jpg_comp.COM_len = 60;
907 zoran_open_init_params (struct zoran *zr)
911 /* User must explicitly set a window */
912 zr->overlay_settings.is_set = 0;
913 zr->overlay_mask = NULL;
914 zr->overlay_active = ZORAN_FREE;
916 zr->v4l_memgrab_active = 0;
917 zr->v4l_overlay_active = 0;
918 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
919 zr->v4l_grab_seq = 0;
920 zr->v4l_settings.width = 192;
921 zr->v4l_settings.height = 144;
922 zr->v4l_settings.format = &zoran_formats[4]; /* YUY2 - YUV-4:2:2 packed */
923 zr->v4l_settings.bytesperline =
924 zr->v4l_settings.width *
925 ((zr->v4l_settings.format->depth + 7) / 8);
927 /* DMA ring stuff for V4L */
928 zr->v4l_pend_tail = 0;
929 zr->v4l_pend_head = 0;
930 zr->v4l_sync_tail = 0;
931 zr->v4l_buffers.active = ZORAN_FREE;
932 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
933 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
935 zr->v4l_buffers.allocated = 0;
937 for (i = 0; i < BUZ_MAX_FRAME; i++) {
938 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
940 zr->jpg_buffers.active = ZORAN_FREE;
941 zr->jpg_buffers.allocated = 0;
942 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
943 zr->jpg_settings.decimation = 1;
944 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
945 if (zr->card.type != BUZ)
946 zr->jpg_settings.odd_even = 1;
948 zr->jpg_settings.odd_even = 0;
949 zr->jpg_settings.jpg_comp.APPn = 0;
950 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
951 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
952 sizeof(zr->jpg_settings.jpg_comp.APP_data));
953 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
954 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
955 sizeof(zr->jpg_settings.jpg_comp.COM_data));
956 zr->jpg_settings.jpg_comp.jpeg_markers =
957 JPEG_MARKER_DHT | JPEG_MARKER_DQT;
958 i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
962 "%s: zoran_open_init_params() internal error\n",
965 clear_interrupt_counters(zr);
969 static void __devinit
970 test_interrupts (struct zoran *zr)
975 clear_interrupt_counters(zr);
978 icr = btread(ZR36057_ICR);
979 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
980 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
981 timeout = schedule_timeout(HZ);
982 finish_wait(&zr->test_q, &wait);
983 btwrite(0, ZR36057_ICR);
984 btwrite(0x78000000, ZR36057_ISR);
986 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
988 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
991 print_interrupts(zr);
992 btwrite(icr, ZR36057_ICR);
996 zr36057_init (struct zoran *zr)
1004 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1005 ZR_DEVNAME(zr), zr->id, zr);
1007 /* default setup of all parameters which will persist between opens */
1010 init_waitqueue_head(&zr->v4l_capq);
1011 init_waitqueue_head(&zr->jpg_capq);
1012 init_waitqueue_head(&zr->test_q);
1013 zr->jpg_buffers.allocated = 0;
1014 zr->v4l_buffers.allocated = 0;
1016 zr->buffer.base = (void *) vidmem;
1017 zr->buffer.width = 0;
1018 zr->buffer.height = 0;
1019 zr->buffer.depth = 0;
1020 zr->buffer.bytesperline = 0;
1022 /* Avoid nonsense settings from user for default input/norm */
1023 if (default_norm < VIDEO_MODE_PAL &&
1024 default_norm > VIDEO_MODE_SECAM)
1025 default_norm = VIDEO_MODE_PAL;
1026 zr->norm = default_norm;
1027 if (!(zr->timing = zr->card.tvn[zr->norm])) {
1030 "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1032 zr->norm = VIDEO_MODE_PAL;
1033 zr->timing = zr->card.tvn[zr->norm];
1036 zr->input = default_input = (default_input ? 1 : 0);
1038 /* Should the following be reset at every open ? */
1040 zr->contrast = 32768;
1041 zr->saturation = 32768;
1042 zr->brightness = 32768;
1044 /* default setup (will be repeated at every open) */
1045 zoran_open_init_params(zr);
1047 /* allocate memory *before* doing anything to the hardware
1048 * in case allocation fails */
1049 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1050 zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1051 if (!zr->stat_com || !zr->video_dev) {
1054 "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1059 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1060 zr->stat_com[j] = 1; /* mark as unavailable to zr36057 */
1064 * Now add the template and register the device unit.
1066 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1067 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1068 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr);
1070 goto exit_unregister;
1072 zoran_init_hardware(zr);
1074 detect_guest_activity(zr);
1075 test_interrupts(zr);
1076 if (!pass_through) {
1077 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1078 encoder_command(zr, ENCODER_SET_INPUT, &two);
1081 zr->zoran_proc = NULL;
1082 zr->initialized = 1;
1086 zoran_unregister_i2c(zr);
1088 kfree(zr->stat_com);
1089 kfree(zr->video_dev);
1094 zoran_release (struct zoran *zr)
1096 if (!zr->initialized)
1098 /* unregister videocodec bus */
1100 struct videocodec_master *master = zr->codec->master_data;
1102 videocodec_detach(zr->codec);
1106 struct videocodec_master *master = zr->vfe->master_data;
1108 videocodec_detach(zr->vfe);
1112 /* unregister i2c bus */
1113 zoran_unregister_i2c(zr);
1114 /* disable PCI bus-mastering */
1115 zoran_set_pci_master(zr, 0);
1116 /* put chip into reset */
1117 btwrite(0, ZR36057_SPGPPCR);
1118 free_irq(zr->pci_dev->irq, zr);
1119 /* unmap and free memory */
1120 kfree(zr->stat_com);
1121 zoran_proc_cleanup(zr);
1122 iounmap(zr->zr36057_mem);
1123 pci_disable_device(zr->pci_dev);
1124 video_unregister_device(zr->video_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);
1143 "%s: zoran_setup_videocodec() - no memory\n",
1148 m->magic = 0L; /* magic not used */
1149 m->type = VID_HARDWARE_ZR36067;
1150 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1151 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1156 case CODEC_TYPE_ZR36060:
1157 m->readreg = zr36060_read;
1158 m->writereg = zr36060_write;
1159 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1161 case CODEC_TYPE_ZR36050:
1162 m->readreg = zr36050_read;
1163 m->writereg = zr36050_write;
1164 m->flags |= CODEC_FLAG_JPEG;
1166 case CODEC_TYPE_ZR36016:
1167 m->readreg = zr36016_read;
1168 m->writereg = zr36016_write;
1169 m->flags |= CODEC_FLAG_VFE;
1177 * Scan for a Buz card (actually for the PCI contoler ZR36057),
1178 * request the irq and map the io memory
1180 static int __devinit
1183 unsigned char latency, need_latency;
1185 struct pci_dev *dev = NULL;
1187 struct videocodec_master *master_vfe = NULL;
1188 struct videocodec_master *master_codec = NULL;
1190 char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1193 while (zoran_num < BUZ_MAX &&
1195 pci_find_device(PCI_VENDOR_ID_ZORAN,
1196 PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1197 card_num = card[zoran_num];
1198 zr = &zoran[zoran_num];
1199 memset(zr, 0, sizeof(struct zoran)); // Just in case if previous cycle failed
1201 //zr->zr36057_mem = NULL;
1203 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1204 spin_lock_init(&zr->spinlock);
1205 init_MUTEX(&zr->resource_lock);
1206 if (pci_enable_device(dev))
1208 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1209 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1211 if (zr->revision < 2) {
1214 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1215 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1218 if (card_num == -1) {
1221 "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1227 unsigned short ss_vendor, ss_device;
1229 ss_vendor = zr->pci_dev->subsystem_vendor;
1230 ss_device = zr->pci_dev->subsystem_device;
1233 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1234 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1238 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1239 ZR_DEVNAME(zr), ss_vendor, ss_device);
1240 if (card_num == -1) {
1243 "%s: find_zr36057() - trying to autodetect card type\n",
1245 for (i=0;i<NUM_CARDS;i++) {
1246 if (ss_vendor == zoran_cards[i].vendor_id &&
1247 ss_device == zoran_cards[i].device_id) {
1250 "%s: find_zr36057() - card %s detected\n",
1252 zoran_cards[i].name);
1257 if (i == NUM_CARDS) {
1260 "%s: find_zr36057() - unknown card\n",
1267 if (card_num < 0 || card_num >= NUM_CARDS) {
1270 "%s: find_zr36057() - invalid cardnum %d\n",
1271 ZR_DEVNAME(zr), card_num);
1275 /* even though we make this a non pointer and thus
1276 * theoretically allow for making changes to this struct
1277 * on a per-individual card basis at runtime, this is
1278 * strongly discouraged. This structure is intended to
1279 * keep general card information, no settings or anything */
1280 zr->card = zoran_cards[card_num];
1281 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1282 "%s[%u]", zr->card.name, zr->id);
1284 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1285 if (!zr->zr36057_mem) {
1288 "%s: find_zr36057() - ioremap failed\n",
1293 result = request_irq(zr->pci_dev->irq,
1295 SA_SHIRQ | SA_INTERRUPT,
1299 if (result == -EINVAL) {
1302 "%s: find_zr36057() - bad irq number or handler\n",
1304 } else if (result == -EBUSY) {
1307 "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1308 ZR_DEVNAME(zr), zr->pci_dev->irq);
1312 "%s: find_zr36057() - can't assign irq, error code %d\n",
1313 ZR_DEVNAME(zr), result);
1318 /* set PCI latency timer */
1319 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1321 need_latency = zr->revision > 1 ? 32 : 48;
1322 if (latency != need_latency) {
1325 "%s: Changing PCI latency from %d to %d.\n",
1326 ZR_DEVNAME(zr), latency, need_latency);
1327 pci_write_config_byte(zr->pci_dev,
1332 zr36057_restart(zr);
1334 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1338 if (decoder[zr->id] != -1) {
1339 i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1340 zr->card.i2c_decoder = decoder[zr->id];
1341 } else if (zr->card.i2c_decoder != 0) {
1343 i2cid_to_modulename(zr->card.i2c_decoder);
1345 i2c_dec_name = NULL;
1349 if ((result = request_module(i2c_dec_name)) < 0) {
1352 "%s: failed to load module %s: %d\n",
1353 ZR_DEVNAME(zr), i2c_dec_name, result);
1358 if (encoder[zr->id] != -1) {
1359 i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1360 zr->card.i2c_encoder = encoder[zr->id];
1361 } else if (zr->card.i2c_encoder != 0) {
1363 i2cid_to_modulename(zr->card.i2c_encoder);
1365 i2c_enc_name = NULL;
1369 if ((result = request_module(i2c_enc_name)) < 0) {
1372 "%s: failed to load module %s: %d\n",
1373 ZR_DEVNAME(zr), i2c_enc_name, result);
1377 if (zoran_register_i2c(zr) < 0) {
1380 "%s: find_zr36057() - can't initialize i2c bus\n",
1386 KERN_INFO "%s: Initializing videocodec bus...\n",
1389 if (zr->card.video_codec != 0 &&
1391 codecid_to_modulename(zr->card.video_codec)) != NULL) {
1392 if ((result = request_module(codec_name)) < 0) {
1395 "%s: failed to load modules %s: %d\n",
1396 ZR_DEVNAME(zr), codec_name, result);
1399 if (zr->card.video_vfe != 0 &&
1401 codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1402 if ((result = request_module(vfe_name)) < 0) {
1405 "%s: failed to load modules %s: %d\n",
1406 ZR_DEVNAME(zr), vfe_name, result);
1410 /* reset JPEG codec */
1411 jpeg_codec_sleep(zr, 1);
1412 jpeg_codec_reset(zr);
1413 /* video bus enabled */
1414 /* display codec revision */
1415 if (zr->card.video_codec != 0) {
1416 master_codec = zoran_setup_videocodec(zr,
1417 zr->card.video_codec);
1420 zr->codec = videocodec_attach(master_codec);
1424 "%s: find_zr36057() - no codec found\n",
1428 if (zr->codec->type != zr->card.video_codec) {
1431 "%s: find_zr36057() - wrong codec\n",
1433 goto zr_detach_codec;
1436 if (zr->card.video_vfe != 0) {
1437 master_vfe = zoran_setup_videocodec(zr,
1438 zr->card.video_vfe);
1440 goto zr_detach_codec;
1441 zr->vfe = videocodec_attach(master_vfe);
1445 "%s: find_zr36057() - no VFE found\n",
1449 if (zr->vfe->type != zr->card.video_vfe) {
1452 "%s: find_zr36057() = wrong VFE\n",
1463 videocodec_detach(zr->vfe);
1467 videocodec_detach(zr->codec);
1469 kfree(master_codec);
1471 zoran_unregister_i2c(zr);
1473 btwrite(0, ZR36057_SPGPPCR);
1474 free_irq(zr->pci_dev->irq, zr);
1476 iounmap(zr->zr36057_mem);
1479 if (zoran_num == 0) {
1480 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1486 init_dc10_cards (void)
1490 memset(zoran, 0, sizeof(zoran));
1491 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1492 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1494 /* Look for cards */
1495 if (find_zr36057() < 0) {
1500 dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1502 /* check the parameters we have been given, adjust if necessary */
1505 if (v4l_nbufs > VIDEO_MAX_FRAME)
1506 v4l_nbufs = VIDEO_MAX_FRAME;
1507 /* The user specfies the in KB, we want them in byte
1508 * (and page aligned) */
1509 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1510 if (v4l_bufsize < 32768)
1511 v4l_bufsize = 32768;
1512 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1513 if (v4l_bufsize > 2048 * 1024)
1514 v4l_bufsize = 2048 * 1024;
1517 if (jpg_nbufs > BUZ_MAX_FRAME)
1518 jpg_nbufs = BUZ_MAX_FRAME;
1519 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1520 if (jpg_bufsize < 8192)
1522 if (jpg_bufsize > (512 * 1024))
1523 jpg_bufsize = 512 * 1024;
1524 /* Use parameter for vidmem or try to find a video card */
1528 "%s: Using supplied video memory base address @ 0x%lx\n",
1529 ZORAN_NAME, vidmem);
1532 /* random nonsense */
1533 dprintk(5, KERN_DEBUG "Jotti is een held!\n");
1535 /* some mainboards might not do PCI-PCI data transfer well */
1536 if (pci_pci_problems & PCIPCI_FAIL) {
1539 "%s: chipset may not support reliable PCI-PCI DMA\n",
1543 /* take care of Natoma chipset and a revision 1 zr36057 */
1544 for (i = 0; i < zoran_num; i++) {
1545 struct zoran *zr = &zoran[i];
1547 if (pci_pci_problems & PCIPCI_NATOMA && zr->revision <= 1) {
1548 zr->jpg_buffers.need_contiguous = 1;
1551 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1555 if (zr36057_init(zr) < 0) {
1556 for (i = 0; i < zoran_num; i++)
1557 zoran_release(&zoran[i]);
1560 zoran_proc_init(zr);
1567 unload_dc10_cards (void)
1571 for (i = 0; i < zoran_num; i++)
1572 zoran_release(&zoran[i]);
1575 module_init(init_dc10_cards);
1576 module_exit(unload_dc10_cards);