Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/drivers/media/pci/zoran/zoran_card.c

  1 /*
  2  * Zoran zr36057/zr36067 PCI controller driver, for the
  3  * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
  4  * Media Labs LML33/LML33R10.
  5  *
  6  * This part handles card-specific data and detection
  7  *
  8  * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
  9  *
 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>
 14  *
 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.
 19  *
 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.
 24  *
 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.
 28  */
 29 
 30 #include <linux/delay.h>
 31 
 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>
 38 
 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>
 47 
 48 #include <linux/pci.h>
 49 #include <linux/interrupt.h>
 50 #include <linux/mutex.h>
 51 #include <linux/io.h>
 52 #include <media/v4l2-common.h>
 53 #include <media/i2c/bt819.h>
 54 
 55 #include "videocodec.h"
 56 #include "zoran.h"
 57 #include "zoran_card.h"
 58 #include "zoran_device.h"
 59 #include "zoran_procfs.h"
 60 
 61 extern const struct zoran_format zoran_formats[];
 62 
 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");
 66 
 67 /*
 68    The video mem address of the video card.
 69    The driver has a little database for some videocards
 70    to determine it from there. If your video card is not in there
 71    you have either to give it to the driver as a parameter
 72    or set in in a VIDIOCSFBUF ioctl
 73  */
 74 
 75 static unsigned long vidmem;    /* default = 0 - Video memory base address */
 76 module_param(vidmem, ulong, 0444);
 77 MODULE_PARM_DESC(vidmem, "Default video memory base address");
 78 
 79 /*
 80    Default input and video norm at startup of the driver.
 81 */
 82 
 83 static unsigned int default_input;      /* default 0 = Composite, 1 = S-Video */
 84 module_param(default_input, uint, 0444);
 85 MODULE_PARM_DESC(default_input,
 86                  "Default input (0=Composite, 1=S-Video, 2=Internal)");
 87 
 88 static int default_mux = 1;     /* 6 Eyes input selection */
 89 module_param(default_mux, int, 0644);
 90 MODULE_PARM_DESC(default_mux,
 91                  "Default 6 Eyes mux setting (Input selection)");
 92 
 93 static int default_norm;        /* default 0 = PAL, 1 = NTSC 2 = SECAM */
 94 module_param(default_norm, int, 0444);
 95 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
 96 
 97 /* /dev/videoN, -1 for autodetect */
 98 static int video_nr[BUZ_MAX] = { [0 ... (BUZ_MAX-1)] = -1 };
 99 module_param_array(video_nr, int, NULL, 0444);
100 MODULE_PARM_DESC(video_nr, "Video device number (-1=Auto)");
101 
102 int v4l_nbufs = 4;
103 int v4l_bufsize = 864;          /* Everybody should be able to work with this setting */
104 module_param(v4l_nbufs, int, 0644);
105 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
106 module_param(v4l_bufsize, int, 0644);
107 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
108 
109 int jpg_nbufs = 32;
110 int jpg_bufsize = 512;          /* max size for 100% quality full-PAL frame */
111 module_param(jpg_nbufs, int, 0644);
112 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
113 module_param(jpg_bufsize, int, 0644);
114 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
115 
116 int pass_through = 0;           /* 1=Pass through TV signal when device is not used */
117                                 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
118 module_param(pass_through, int, 0644);
119 MODULE_PARM_DESC(pass_through,
120                  "Pass TV signal through to TV-out when idling");
121 
122 int zr36067_debug = 1;
123 module_param_named(debug, zr36067_debug, int, 0644);
124 MODULE_PARM_DESC(debug, "Debug level (0-5)");
125 
126 #define ZORAN_VERSION "0.10.1"
127 
128 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
129 MODULE_AUTHOR("Serguei Miridonov");
130 MODULE_LICENSE("GPL");
131 MODULE_VERSION(ZORAN_VERSION);
132 
133 #define ZR_DEVICE(subven, subdev, data) { \
134         .vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \
135         .subvendor = (subven), .subdevice = (subdev), .driver_data = (data) }
136 
137 static struct pci_device_id zr36067_pci_tbl[] = {
138         ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC10PLUS, DC10plus),
139         ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC30PLUS, DC30plus),
140         ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH, PCI_DEVICE_ID_LML_33R10, LML33R10),
141         ZR_DEVICE(PCI_VENDOR_ID_IOMEGA, PCI_DEVICE_ID_IOMEGA_BUZ, BUZ),
142         ZR_DEVICE(PCI_ANY_ID, PCI_ANY_ID, NUM_CARDS),
143         {0}
144 };
145 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
146 
147 static unsigned int zoran_num;          /* number of cards found */
148 
149 /* videocodec bus functions ZR36060 */
150 static u32
151 zr36060_read (struct videocodec *codec,
152               u16                reg)
153 {
154         struct zoran *zr = (struct zoran *) codec->master_data->data;
155         __u32 data;
156 
157         if (post_office_wait(zr)
158             || post_office_write(zr, 0, 1, reg >> 8)
159             || post_office_write(zr, 0, 2, reg & 0xff)) {
160                 return -1;
161         }
162 
163         data = post_office_read(zr, 0, 3) & 0xff;
164         return data;
165 }
166 
167 static void
168 zr36060_write (struct videocodec *codec,
169                u16                reg,
170                u32                val)
171 {
172         struct zoran *zr = (struct zoran *) codec->master_data->data;
173 
174         if (post_office_wait(zr)
175             || post_office_write(zr, 0, 1, reg >> 8)
176             || post_office_write(zr, 0, 2, reg & 0xff)) {
177                 return;
178         }
179 
180         post_office_write(zr, 0, 3, val & 0xff);
181 }
182 
183 /* videocodec bus functions ZR36050 */
184 static u32
185 zr36050_read (struct videocodec *codec,
186               u16                reg)
187 {
188         struct zoran *zr = (struct zoran *) codec->master_data->data;
189         __u32 data;
190 
191         if (post_office_wait(zr)
192             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
193                 return -1;
194         }
195 
196         data = post_office_read(zr, 0, reg & 0x03) & 0xff;      // reg. LOWBYTES + read
197         return data;
198 }
199 
200 static void
201 zr36050_write (struct videocodec *codec,
202                u16                reg,
203                u32                val)
204 {
205         struct zoran *zr = (struct zoran *) codec->master_data->data;
206 
207         if (post_office_wait(zr)
208             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
209                 return;
210         }
211 
212         post_office_write(zr, 0, reg & 0x03, val & 0xff);       // reg. LOWBYTES + wr. data
213 }
214 
215 /* videocodec bus functions ZR36016 */
216 static u32
217 zr36016_read (struct videocodec *codec,
218               u16                reg)
219 {
220         struct zoran *zr = (struct zoran *) codec->master_data->data;
221         __u32 data;
222 
223         if (post_office_wait(zr)) {
224                 return -1;
225         }
226 
227         data = post_office_read(zr, 2, reg & 0x03) & 0xff;      // read
228         return data;
229 }
230 
231 /* hack for in zoran_device.c */
232 void
233 zr36016_write (struct videocodec *codec,
234                u16                reg,
235                u32                val)
236 {
237         struct zoran *zr = (struct zoran *) codec->master_data->data;
238 
239         if (post_office_wait(zr)) {
240                 return;
241         }
242 
243         post_office_write(zr, 2, reg & 0x03, val & 0x0ff);      // wr. data
244 }
245 
246 /*
247  * Board specific information
248  */
249 
250 static void
251 dc10_init (struct zoran *zr)
252 {
253         dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
254 
255         /* Pixel clock selection */
256         GPIO(zr, 4, 0);
257         GPIO(zr, 5, 1);
258         /* Enable the video bus sync signals */
259         GPIO(zr, 7, 0);
260 }
261 
262 static void
263 dc10plus_init (struct zoran *zr)
264 {
265         dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
266 }
267 
268 static void
269 buz_init (struct zoran *zr)
270 {
271         dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
272 
273         /* some stuff from Iomega */
274         pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
275         pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
276         pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
277 }
278 
279 static void
280 lml33_init (struct zoran *zr)
281 {
282         dprintk(3, KERN_DEBUG "%s: %s\n", ZR_DEVNAME(zr), __func__);
283 
284         GPIO(zr, 2, 1);         // Set Composite input/output
285 }
286 
287 static void
288 avs6eyes_init (struct zoran *zr)
289 {
290         // AverMedia 6-Eyes original driver by Christer Weinigel
291 
292         // Lifted straight from Christer's old driver and
293         // modified slightly by Martin Samuelsson.
294 
295         int mux = default_mux; /* 1 = BT866, 7 = VID1 */
296 
297         GPIO(zr, 4, 1); /* Bt866 SLEEP on */
298         udelay(2);
299 
300         GPIO(zr, 0, 1); /* ZR36060 /RESET on */
301         GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
302         GPIO(zr, 2, mux & 1);   /* MUX S0 */
303         GPIO(zr, 3, 0); /* /FRAME on */
304         GPIO(zr, 4, 0); /* Bt866 SLEEP off */
305         GPIO(zr, 5, mux & 2);   /* MUX S1 */
306         GPIO(zr, 6, 0); /* ? */
307         GPIO(zr, 7, mux & 4);   /* MUX S2 */
308 
309 }
310 
311 static char *
312 codecid_to_modulename (u16 codecid)
313 {
314         char *name = NULL;
315 
316         switch (codecid) {
317         case CODEC_TYPE_ZR36060:
318                 name = "zr36060";
319                 break;
320         case CODEC_TYPE_ZR36050:
321                 name = "zr36050";
322                 break;
323         case CODEC_TYPE_ZR36016:
324                 name = "zr36016";
325                 break;
326         }
327 
328         return name;
329 }
330 
331 // struct tvnorm {
332 //      u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
333 // };
334 
335 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
336 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
337 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
338 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
339 
340 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
341 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
342 
343 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
344 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
345 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
346 
347 /* FIXME: I cannot swap U and V in saa7114, so i do one
348  * pixel left shift in zoran (75 -> 74)
349  * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
350 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
351 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
352 
353 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
354  * copy Maxim's left shift hack for the 6 Eyes.
355  *
356  * Christer's driver used the unshifted norms, though...
357  * /Sam  */
358 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
359 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
360 
361 static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END };
362 static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END };
363 static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END };
364 static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END };
365 static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END };
366 static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END };
367 static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END };
368 static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END };
369 static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END };
370 static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END };
371 
372 static struct card_info zoran_cards[NUM_CARDS] = {
373         {
374                 .type = DC10_old,
375                 .name = "DC10(old)",
376                 .i2c_decoder = "vpx3220a",
377                 .addrs_decoder = vpx3220_addrs,
378                 .video_codec = CODEC_TYPE_ZR36050,
379                 .video_vfe = CODEC_TYPE_ZR36016,
380 
381                 .inputs = 3,
382                 .input = {
383                         { 1, "Composite" },
384                         { 2, "S-Video" },
385                         { 0, "Internal/comp" }
386                 },
387                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
388                 .tvn = {
389                         &f50sqpixel_dc10,
390                         &f60sqpixel_dc10,
391                         &f50sqpixel_dc10
392                 },
393                 .jpeg_int = 0,
394                 .vsync_int = ZR36057_ISR_GIRQ1,
395                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
396                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
397                 .gpcs = { -1, 0 },
398                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
399                 .gws_not_connected = 0,
400                 .input_mux = 0,
401                 .init = &dc10_init,
402         }, {
403                 .type = DC10_new,
404                 .name = "DC10(new)",
405                 .i2c_decoder = "saa7110",
406                 .addrs_decoder = saa7110_addrs,
407                 .i2c_encoder = "adv7175",
408                 .addrs_encoder = adv717x_addrs,
409                 .video_codec = CODEC_TYPE_ZR36060,
410 
411                 .inputs = 3,
412                 .input = {
413                                 { 0, "Composite" },
414                                 { 7, "S-Video" },
415                                 { 5, "Internal/comp" }
416                         },
417                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
418                 .tvn = {
419                                 &f50sqpixel,
420                                 &f60sqpixel,
421                                 &f50sqpixel},
422                 .jpeg_int = ZR36057_ISR_GIRQ0,
423                 .vsync_int = ZR36057_ISR_GIRQ1,
424                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
425                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
426                 .gpcs = { -1, 1},
427                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
428                 .gws_not_connected = 0,
429                 .input_mux = 0,
430                 .init = &dc10plus_init,
431         }, {
432                 .type = DC10plus,
433                 .name = "DC10plus",
434                 .i2c_decoder = "saa7110",
435                 .addrs_decoder = saa7110_addrs,
436                 .i2c_encoder = "adv7175",
437                 .addrs_encoder = adv717x_addrs,
438                 .video_codec = CODEC_TYPE_ZR36060,
439 
440                 .inputs = 3,
441                 .input = {
442                         { 0, "Composite" },
443                         { 7, "S-Video" },
444                         { 5, "Internal/comp" }
445                 },
446                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
447                 .tvn = {
448                         &f50sqpixel,
449                         &f60sqpixel,
450                         &f50sqpixel
451                 },
452                 .jpeg_int = ZR36057_ISR_GIRQ0,
453                 .vsync_int = ZR36057_ISR_GIRQ1,
454                 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
455                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
456                 .gpcs = { -1, 1 },
457                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
458                 .gws_not_connected = 0,
459                 .input_mux = 0,
460                 .init = &dc10plus_init,
461         }, {
462                 .type = DC30,
463                 .name = "DC30",
464                 .i2c_decoder = "vpx3220a",
465                 .addrs_decoder = vpx3220_addrs,
466                 .i2c_encoder = "adv7175",
467                 .addrs_encoder = adv717x_addrs,
468                 .video_codec = CODEC_TYPE_ZR36050,
469                 .video_vfe = CODEC_TYPE_ZR36016,
470 
471                 .inputs = 3,
472                 .input = {
473                         { 1, "Composite" },
474                         { 2, "S-Video" },
475                         { 0, "Internal/comp" }
476                 },
477                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
478                 .tvn = {
479                         &f50sqpixel_dc10,
480                         &f60sqpixel_dc10,
481                         &f50sqpixel_dc10
482                 },
483                 .jpeg_int = 0,
484                 .vsync_int = ZR36057_ISR_GIRQ1,
485                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
486                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
487                 .gpcs = { -1, 0 },
488                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
489                 .gws_not_connected = 0,
490                 .input_mux = 0,
491                 .init = &dc10_init,
492         }, {
493                 .type = DC30plus,
494                 .name = "DC30plus",
495                 .i2c_decoder = "vpx3220a",
496                 .addrs_decoder = vpx3220_addrs,
497                 .i2c_encoder = "adv7175",
498                 .addrs_encoder = adv717x_addrs,
499                 .video_codec = CODEC_TYPE_ZR36050,
500                 .video_vfe = CODEC_TYPE_ZR36016,
501 
502                 .inputs = 3,
503                 .input = {
504                         { 1, "Composite" },
505                         { 2, "S-Video" },
506                         { 0, "Internal/comp" }
507                 },
508                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
509                 .tvn = {
510                         &f50sqpixel_dc10,
511                         &f60sqpixel_dc10,
512                         &f50sqpixel_dc10
513                 },
514                 .jpeg_int = 0,
515                 .vsync_int = ZR36057_ISR_GIRQ1,
516                 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
517                 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
518                 .gpcs = { -1, 0 },
519                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
520                 .gws_not_connected = 0,
521                 .input_mux = 0,
522                 .init = &dc10_init,
523         }, {
524                 .type = LML33,
525                 .name = "LML33",
526                 .i2c_decoder = "bt819a",
527                 .addrs_decoder = bt819_addrs,
528                 .i2c_encoder = "bt856",
529                 .addrs_encoder = bt856_addrs,
530                 .video_codec = CODEC_TYPE_ZR36060,
531 
532                 .inputs = 2,
533                 .input = {
534                         { 0, "Composite" },
535                         { 7, "S-Video" }
536                 },
537                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL,
538                 .tvn = {
539                         &f50ccir601_lml33,
540                         &f60ccir601_lml33,
541                         NULL
542                 },
543                 .jpeg_int = ZR36057_ISR_GIRQ1,
544                 .vsync_int = ZR36057_ISR_GIRQ0,
545                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
546                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
547                 .gpcs = { 3, 1 },
548                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
549                 .gws_not_connected = 1,
550                 .input_mux = 0,
551                 .init = &lml33_init,
552         }, {
553                 .type = LML33R10,
554                 .name = "LML33R10",
555                 .i2c_decoder = "saa7114",
556                 .addrs_decoder = saa7114_addrs,
557                 .i2c_encoder = "adv7170",
558                 .addrs_encoder = adv717x_addrs,
559                 .video_codec = CODEC_TYPE_ZR36060,
560 
561                 .inputs = 2,
562                 .input = {
563                         { 0, "Composite" },
564                         { 7, "S-Video" }
565                 },
566                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL,
567                 .tvn = {
568                         &f50ccir601_lm33r10,
569                         &f60ccir601_lm33r10,
570                         NULL
571                 },
572                 .jpeg_int = ZR36057_ISR_GIRQ1,
573                 .vsync_int = ZR36057_ISR_GIRQ0,
574                 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
575                 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
576                 .gpcs = { 3, 1 },
577                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
578                 .gws_not_connected = 1,
579                 .input_mux = 0,
580                 .init = &lml33_init,
581         }, {
582                 .type = BUZ,
583                 .name = "Buz",
584                 .i2c_decoder = "saa7111",
585                 .addrs_decoder = saa7111_addrs,
586                 .i2c_encoder = "saa7185",
587                 .addrs_encoder = saa7185_addrs,
588                 .video_codec = CODEC_TYPE_ZR36060,
589 
590                 .inputs = 2,
591                 .input = {
592                         { 3, "Composite" },
593                         { 7, "S-Video" }
594                 },
595                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL|V4L2_STD_SECAM,
596                 .tvn = {
597                         &f50ccir601,
598                         &f60ccir601,
599                         &f50ccir601
600                 },
601                 .jpeg_int = ZR36057_ISR_GIRQ1,
602                 .vsync_int = ZR36057_ISR_GIRQ0,
603                 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
604                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
605                 .gpcs = { 3, 1 },
606                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
607                 .gws_not_connected = 1,
608                 .input_mux = 0,
609                 .init = &buz_init,
610         }, {
611                 .type = AVS6EYES,
612                 .name = "6-Eyes",
613                 /* AverMedia chose not to brand the 6-Eyes. Thus it
614                    can't be autodetected, and requires card=x. */
615                 .i2c_decoder = "ks0127",
616                 .addrs_decoder = ks0127_addrs,
617                 .i2c_encoder = "bt866",
618                 .addrs_encoder = bt866_addrs,
619                 .video_codec = CODEC_TYPE_ZR36060,
620 
621                 .inputs = 10,
622                 .input = {
623                         { 0, "Composite 1" },
624                         { 1, "Composite 2" },
625                         { 2, "Composite 3" },
626                         { 4, "Composite 4" },
627                         { 5, "Composite 5" },
628                         { 6, "Composite 6" },
629                         { 8, "S-Video 1" },
630                         { 9, "S-Video 2" },
631                         {10, "S-Video 3" },
632                         {15, "YCbCr" }
633                 },
634                 .norms = V4L2_STD_NTSC|V4L2_STD_PAL,
635                 .tvn = {
636                         &f50ccir601_avs6eyes,
637                         &f60ccir601_avs6eyes,
638                         NULL
639                 },
640                 .jpeg_int = ZR36057_ISR_GIRQ1,
641                 .vsync_int = ZR36057_ISR_GIRQ0,
642                 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
643                 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
644                 .gpcs = { 3, 1 },                       // Validity unknown /Sam
645                 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },  // Validity unknown /Sam
646                 .gws_not_connected = 1,
647                 .input_mux = 1,
648                 .init = &avs6eyes_init,
649         }
650 
651 };
652 
653 /*
654  * I2C functions
655  */
656 /* software I2C functions */
657 static int
658 zoran_i2c_getsda (void *data)
659 {
660         struct zoran *zr = (struct zoran *) data;
661 
662         return (btread(ZR36057_I2CBR) >> 1) & 1;
663 }
664 
665 static int
666 zoran_i2c_getscl (void *data)
667 {
668         struct zoran *zr = (struct zoran *) data;
669 
670         return btread(ZR36057_I2CBR) & 1;
671 }
672 
673 static void
674 zoran_i2c_setsda (void *data,
675                   int   state)
676 {
677         struct zoran *zr = (struct zoran *) data;
678 
679         if (state)
680                 zr->i2cbr |= 2;
681         else
682                 zr->i2cbr &= ~2;
683         btwrite(zr->i2cbr, ZR36057_I2CBR);
684 }
685 
686 static void
687 zoran_i2c_setscl (void *data,
688                   int   state)
689 {
690         struct zoran *zr = (struct zoran *) data;
691 
692         if (state)
693                 zr->i2cbr |= 1;
694         else
695                 zr->i2cbr &= ~1;
696         btwrite(zr->i2cbr, ZR36057_I2CBR);
697 }
698 
699 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
700         .setsda = zoran_i2c_setsda,
701         .setscl = zoran_i2c_setscl,
702         .getsda = zoran_i2c_getsda,
703         .getscl = zoran_i2c_getscl,
704         .udelay = 10,
705         .timeout = 100,
706 };
707 
708 static int
709 zoran_register_i2c (struct zoran *zr)
710 {
711         zr->i2c_algo = zoran_i2c_bit_data_template;
712         zr->i2c_algo.data = zr;
713         strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
714                 sizeof(zr->i2c_adapter.name));
715         i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
716         zr->i2c_adapter.algo_data = &zr->i2c_algo;
717         zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
718         return i2c_bit_add_bus(&zr->i2c_adapter);
719 }
720 
721 static void
722 zoran_unregister_i2c (struct zoran *zr)
723 {
724         i2c_del_adapter(&zr->i2c_adapter);
725 }
726 
727 /* Check a zoran_params struct for correctness, insert default params */
728 
729 int
730 zoran_check_jpg_settings (struct zoran              *zr,
731                           struct zoran_jpg_settings *settings,
732                           int try)
733 {
734         int err = 0, err0 = 0;
735 
736         dprintk(4,
737                 KERN_DEBUG
738                 "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
739                 ZR_DEVNAME(zr), __func__, settings->decimation, settings->HorDcm,
740                 settings->VerDcm, settings->TmpDcm);
741         dprintk(4,
742                 KERN_DEBUG
743                 "%s: %s - x: %d, y: %d, w: %d, y: %d\n",
744                 ZR_DEVNAME(zr), __func__, settings->img_x, settings->img_y,
745                 settings->img_width, settings->img_height);
746         /* Check decimation, set default values for decimation = 1, 2, 4 */
747         switch (settings->decimation) {
748         case 1:
749 
750                 settings->HorDcm = 1;
751                 settings->VerDcm = 1;
752                 settings->TmpDcm = 1;
753                 settings->field_per_buff = 2;
754                 settings->img_x = 0;
755                 settings->img_y = 0;
756                 settings->img_width = BUZ_MAX_WIDTH;
757                 settings->img_height = BUZ_MAX_HEIGHT / 2;
758                 break;
759         case 2:
760 
761                 settings->HorDcm = 2;
762                 settings->VerDcm = 1;
763                 settings->TmpDcm = 2;
764                 settings->field_per_buff = 1;
765                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
766                 settings->img_y = 0;
767                 settings->img_width =
768                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
769                 settings->img_height = BUZ_MAX_HEIGHT / 2;
770                 break;
771         case 4:
772 
773                 if (zr->card.type == DC10_new) {
774                         dprintk(1,
775                                 KERN_DEBUG
776                                 "%s: %s - HDec by 4 is not supported on the DC10\n",
777                                 ZR_DEVNAME(zr), __func__);
778                         err0++;
779                         break;
780                 }
781 
782                 settings->HorDcm = 4;
783                 settings->VerDcm = 2;
784                 settings->TmpDcm = 2;
785                 settings->field_per_buff = 1;
786                 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
787                 settings->img_y = 0;
788                 settings->img_width =
789                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
790                 settings->img_height = BUZ_MAX_HEIGHT / 2;
791                 break;
792         case 0:
793 
794                 /* We have to check the data the user has set */
795 
796                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
797                     (zr->card.type == DC10_new || settings->HorDcm != 4)) {
798                         settings->HorDcm = clamp(settings->HorDcm, 1, 2);
799                         err0++;
800                 }
801                 if (settings->VerDcm != 1 && settings->VerDcm != 2) {
802                         settings->VerDcm = clamp(settings->VerDcm, 1, 2);
803                         err0++;
804                 }
805                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2) {
806                         settings->TmpDcm = clamp(settings->TmpDcm, 1, 2);
807                         err0++;
808                 }
809                 if (settings->field_per_buff != 1 &&
810                     settings->field_per_buff != 2) {
811                         settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
812                         err0++;
813                 }
814                 if (settings->img_x < 0) {
815                         settings->img_x = 0;
816                         err0++;
817                 }
818                 if (settings->img_y < 0) {
819                         settings->img_y = 0;
820                         err0++;
821                 }
822                 if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
823                         settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
824                         err0++;
825                 }
826                 if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
827                         settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
828                         err0++;
829                 }
830                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
831                         settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
832                         err0++;
833                 }
834                 if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
835                         settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
836                         err0++;
837                 }
838                 if (settings->img_width % (16 * settings->HorDcm) != 0) {
839                         settings->img_width -= settings->img_width % (16 * settings->HorDcm);
840                         if (settings->img_width == 0)
841                                 settings->img_width = 16 * settings->HorDcm;
842                         err0++;
843                 }
844                 if (settings->img_height % (8 * settings->VerDcm) != 0) {
845                         settings->img_height -= settings->img_height % (8 * settings->VerDcm);
846                         if (settings->img_height == 0)
847                                 settings->img_height = 8 * settings->VerDcm;
848                         err0++;
849                 }
850 
851                 if (!try && err0) {
852                         dprintk(1,
853                                 KERN_ERR
854                                 "%s: %s - error in params for decimation = 0\n",
855                                 ZR_DEVNAME(zr), __func__);
856                         err++;
857                 }
858                 break;
859         default:
860                 dprintk(1,
861                         KERN_ERR
862                         "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n",
863                         ZR_DEVNAME(zr), __func__, settings->decimation);
864                 err++;
865                 break;
866         }
867 
868         if (settings->jpg_comp.quality > 100)
869                 settings->jpg_comp.quality = 100;
870         if (settings->jpg_comp.quality < 5)
871                 settings->jpg_comp.quality = 5;
872         if (settings->jpg_comp.APPn < 0)
873                 settings->jpg_comp.APPn = 0;
874         if (settings->jpg_comp.APPn > 15)
875                 settings->jpg_comp.APPn = 15;
876         if (settings->jpg_comp.APP_len < 0)
877                 settings->jpg_comp.APP_len = 0;
878         if (settings->jpg_comp.APP_len > 60)
879                 settings->jpg_comp.APP_len = 60;
880         if (settings->jpg_comp.COM_len < 0)
881                 settings->jpg_comp.COM_len = 0;
882         if (settings->jpg_comp.COM_len > 60)
883                 settings->jpg_comp.COM_len = 60;
884         if (err)
885                 return -EINVAL;
886         return 0;
887 }
888 
889 void
890 zoran_open_init_params (struct zoran *zr)
891 {
892         int i;
893 
894         /* User must explicitly set a window */
895         zr->overlay_settings.is_set = 0;
896         zr->overlay_mask = NULL;
897         zr->overlay_active = ZORAN_FREE;
898 
899         zr->v4l_memgrab_active = 0;
900         zr->v4l_overlay_active = 0;
901         zr->v4l_grab_frame = NO_GRAB_ACTIVE;
902         zr->v4l_grab_seq = 0;
903         zr->v4l_settings.width = 192;
904         zr->v4l_settings.height = 144;
905         zr->v4l_settings.format = &zoran_formats[7];    /* YUY2 - YUV-4:2:2 packed */
906         zr->v4l_settings.bytesperline =
907             zr->v4l_settings.width *
908             ((zr->v4l_settings.format->depth + 7) / 8);
909 
910         /* DMA ring stuff for V4L */
911         zr->v4l_pend_tail = 0;
912         zr->v4l_pend_head = 0;
913         zr->v4l_sync_tail = 0;
914         zr->v4l_buffers.active = ZORAN_FREE;
915         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
916                 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
917         }
918         zr->v4l_buffers.allocated = 0;
919 
920         for (i = 0; i < BUZ_MAX_FRAME; i++) {
921                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
922         }
923         zr->jpg_buffers.active = ZORAN_FREE;
924         zr->jpg_buffers.allocated = 0;
925         /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
926         zr->jpg_settings.decimation = 1;
927         zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
928         if (zr->card.type != BUZ)
929                 zr->jpg_settings.odd_even = 1;
930         else
931                 zr->jpg_settings.odd_even = 0;
932         zr->jpg_settings.jpg_comp.APPn = 0;
933         zr->jpg_settings.jpg_comp.APP_len = 0;  /* No APPn marker */
934         memset(zr->jpg_settings.jpg_comp.APP_data, 0,
935                sizeof(zr->jpg_settings.jpg_comp.APP_data));
936         zr->jpg_settings.jpg_comp.COM_len = 0;  /* No COM marker */
937         memset(zr->jpg_settings.jpg_comp.COM_data, 0,
938                sizeof(zr->jpg_settings.jpg_comp.COM_data));
939         zr->jpg_settings.jpg_comp.jpeg_markers =
940             V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT;
941         i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
942         if (i)
943                 dprintk(1, KERN_ERR "%s: %s internal error\n",
944                         ZR_DEVNAME(zr), __func__);
945 
946         clear_interrupt_counters(zr);
947         zr->testing = 0;
948 }
949 
950 static void test_interrupts (struct zoran *zr)
951 {
952         DEFINE_WAIT(wait);
953         int timeout, icr;
954 
955         clear_interrupt_counters(zr);
956 
957         zr->testing = 1;
958         icr = btread(ZR36057_ICR);
959         btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
960         prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
961         timeout = schedule_timeout(HZ);
962         finish_wait(&zr->test_q, &wait);
963         btwrite(0, ZR36057_ICR);
964         btwrite(0x78000000, ZR36057_ISR);
965         zr->testing = 0;
966         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
967         if (timeout) {
968                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
969         }
970         if (zr36067_debug > 1)
971                 print_interrupts(zr);
972         btwrite(icr, ZR36057_ICR);
973 }
974 
975 static int zr36057_init (struct zoran *zr)
976 {
977         int j, err;
978 
979         dprintk(1,
980                 KERN_INFO
981                 "%s: %s - initializing card[%d], zr=%p\n",
982                 ZR_DEVNAME(zr), __func__, zr->id, zr);
983 
984         /* default setup of all parameters which will persist between opens */
985         zr->user = 0;
986 
987         init_waitqueue_head(&zr->v4l_capq);
988         init_waitqueue_head(&zr->jpg_capq);
989         init_waitqueue_head(&zr->test_q);
990         zr->jpg_buffers.allocated = 0;
991         zr->v4l_buffers.allocated = 0;
992 
993         zr->vbuf_base = (void *) vidmem;
994         zr->vbuf_width = 0;
995         zr->vbuf_height = 0;
996         zr->vbuf_depth = 0;
997         zr->vbuf_bytesperline = 0;
998 
999         /* Avoid nonsense settings from user for default input/norm */
1000         if (default_norm < 0 || default_norm > 2)
1001                 default_norm = 0;
1002         if (default_norm == 0) {
1003                 zr->norm = V4L2_STD_PAL;
1004                 zr->timing = zr->card.tvn[0];
1005         } else if (default_norm == 1) {
1006                 zr->norm = V4L2_STD_NTSC;
1007                 zr->timing = zr->card.tvn[1];
1008         } else {
1009                 zr->norm = V4L2_STD_SECAM;
1010                 zr->timing = zr->card.tvn[2];
1011         }
1012         if (zr->timing == NULL) {
1013                 dprintk(1,
1014                         KERN_WARNING
1015                         "%s: %s - default TV standard not supported by hardware. PAL will be used.\n",
1016                         ZR_DEVNAME(zr), __func__);
1017                 zr->norm = V4L2_STD_PAL;
1018                 zr->timing = zr->card.tvn[0];
1019         }
1020 
1021         if (default_input > zr->card.inputs-1) {
1022                 dprintk(1,
1023                         KERN_WARNING
1024                         "%s: default_input value %d out of range (0-%d)\n",
1025                         ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1026                 default_input = 0;
1027         }
1028         zr->input = default_input;
1029 
1030         /* default setup (will be repeated at every open) */
1031         zoran_open_init_params(zr);
1032 
1033         /* allocate memory *before* doing anything to the hardware
1034          * in case allocation fails */
1035         zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1036         zr->video_dev = video_device_alloc();
1037         if (!zr->stat_com || !zr->video_dev) {
1038                 dprintk(1,
1039                         KERN_ERR
1040                         "%s: %s - kmalloc (STAT_COM) failed\n",
1041                         ZR_DEVNAME(zr), __func__);
1042                 err = -ENOMEM;
1043                 goto exit_free;
1044         }
1045         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1046                 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1047         }
1048 
1049         /*
1050          *   Now add the template and register the device unit.
1051          */
1052         *zr->video_dev = zoran_template;
1053         zr->video_dev->v4l2_dev = &zr->v4l2_dev;
1054         zr->video_dev->lock = &zr->lock;