[PATCH] Fix zoran_card compilation warning
[linux-2.6.git] / drivers / media / video / 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/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>
36
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>
45
46 #include <linux/pci.h>
47 #include <linux/interrupt.h>
48 #include <linux/video_decoder.h>
49 #include <linux/video_encoder.h>
50
51 #include <asm/io.h>
52
53 #include "videocodec.h"
54 #include "zoran.h"
55 #include "zoran_card.h"
56 #include "zoran_device.h"
57 #include "zoran_procfs.h"
58
59 #define I2C_NAME(x) (x)->name
60
61 extern const struct zoran_format zoran_formats[];
62
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");
66
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");
70
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");
74
75 /*
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
81  */
82
83 static unsigned long vidmem = 0;        /* Video memory base address */
84 module_param(vidmem, ulong, 0);
85
86 /*
87    Default input and video norm at startup of the driver.
88 */
89
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)");
94
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)");
98
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");
102
103 /*
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>).
109
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.
115
116    v4l_bufsize has to be given in KB !
117
118 */
119
120 int v4l_nbufs = 2;
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)");
126
127 int jpg_nbufs = 32;
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)");
133
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");
139
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)");
144
145 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
146 MODULE_AUTHOR("Serguei Miridonov");
147 MODULE_LICENSE("GPL");
148
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},
152         {0}
153 };
154 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
155
156 #define dprintk(num, format, args...) \
157         do { \
158                 if (*zr_debug >= num) \
159                         printk(format, ##args); \
160         } while (0)
161
162 int zoran_num;                  /* number of Buzs in use */
163 struct zoran zoran[BUZ_MAX];
164
165 /* videocodec bus functions ZR36060 */
166 static u32
167 zr36060_read (struct videocodec *codec,
168               u16                reg)
169 {
170         struct zoran *zr = (struct zoran *) codec->master_data->data;
171         __u32 data;
172
173         if (post_office_wait(zr)
174             || post_office_write(zr, 0, 1, reg >> 8)
175             || post_office_write(zr, 0, 2, reg & 0xff)) {
176                 return -1;
177         }
178
179         data = post_office_read(zr, 0, 3) & 0xff;
180         return data;
181 }
182
183 static void
184 zr36060_write (struct videocodec *codec,
185                u16                reg,
186                u32                val)
187 {
188         struct zoran *zr = (struct zoran *) codec->master_data->data;
189
190         if (post_office_wait(zr)
191             || post_office_write(zr, 0, 1, reg >> 8)
192             || post_office_write(zr, 0, 2, reg & 0xff)) {
193                 return;
194         }
195
196         post_office_write(zr, 0, 3, val & 0xff);
197 }
198
199 /* videocodec bus functions ZR36050 */
200 static u32
201 zr36050_read (struct videocodec *codec,
202               u16                reg)
203 {
204         struct zoran *zr = (struct zoran *) codec->master_data->data;
205         __u32 data;
206
207         if (post_office_wait(zr)
208             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
209                 return -1;
210         }
211
212         data = post_office_read(zr, 0, reg & 0x03) & 0xff;      // reg. LOWBYTES + read
213         return data;
214 }
215
216 static void
217 zr36050_write (struct videocodec *codec,
218                u16                reg,
219                u32                val)
220 {
221         struct zoran *zr = (struct zoran *) codec->master_data->data;
222
223         if (post_office_wait(zr)
224             || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
225                 return;
226         }
227
228         post_office_write(zr, 0, reg & 0x03, val & 0xff);       // reg. LOWBYTES + wr. data
229 }
230
231 /* videocodec bus functions ZR36016 */
232 static u32
233 zr36016_read (struct videocodec *codec,
234               u16                reg)
235 {
236         struct zoran *zr = (struct zoran *) codec->master_data->data;
237         __u32 data;
238
239         if (post_office_wait(zr)) {
240                 return -1;
241         }
242
243         data = post_office_read(zr, 2, reg & 0x03) & 0xff;      // read
244         return data;
245 }
246
247 /* hack for in zoran_device.c */
248 void
249 zr36016_write (struct videocodec *codec,
250                u16                reg,
251                u32                val)
252 {
253         struct zoran *zr = (struct zoran *) codec->master_data->data;
254
255         if (post_office_wait(zr)) {
256                 return;
257         }
258
259         post_office_write(zr, 2, reg & 0x03, val & 0x0ff);      // wr. data
260 }
261
262 /*
263  * Board specific information
264  */
265
266 static void
267 dc10_init (struct zoran *zr)
268 {
269         dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
270
271         /* Pixel clock selection */
272         GPIO(zr, 4, 0);
273         GPIO(zr, 5, 1);
274         /* Enable the video bus sync signals */
275         GPIO(zr, 7, 0);
276 }
277
278 static void
279 dc10plus_init (struct zoran *zr)
280 {
281         dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
282 }
283
284 static void
285 buz_init (struct zoran *zr)
286 {
287         dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
288
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);
293 }
294
295 static void
296 lml33_init (struct zoran *zr)
297 {
298         dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
299
300         GPIO(zr, 2, 1);         // Set Composite input/output
301 }
302
303 static char *
304 i2cid_to_modulename (u16 i2c_id)
305 {
306         char *name = NULL;
307
308         switch (i2c_id) {
309         case I2C_DRIVERID_SAA7110:
310                 name = "saa7110";
311                 break;
312         case I2C_DRIVERID_SAA7111A:
313                 name = "saa7111";
314                 break;
315         case I2C_DRIVERID_SAA7114:
316                 name = "saa7114";
317                 break;
318         case I2C_DRIVERID_SAA7185B:
319                 name = "saa7185";
320                 break;
321         case I2C_DRIVERID_ADV7170:
322                 name = "adv7170";
323                 break;
324         case I2C_DRIVERID_ADV7175:
325                 name = "adv7175";
326                 break;
327         case I2C_DRIVERID_BT819:
328                 name = "bt819";
329                 break;
330         case I2C_DRIVERID_BT856:
331                 name = "bt856";
332                 break;
333         case I2C_DRIVERID_VPX3220:
334                 name = "vpx3220";
335                 break;
336 /*      case I2C_DRIVERID_VPX3224:
337                 name = "vpx3224";
338                 break;
339         case I2C_DRIVERID_MSE3000:
340                 name = "mse3000";
341                 break;*/
342         default:
343                 break;
344         }
345
346         return name;
347 }
348
349 static char *
350 codecid_to_modulename (u16 codecid)
351 {
352         char *name = NULL;
353
354         switch (codecid) {
355         case CODEC_TYPE_ZR36060:
356                 name = "zr36060";
357                 break;
358         case CODEC_TYPE_ZR36050:
359                 name = "zr36050";
360                 break;
361         case CODEC_TYPE_ZR36016:
362                 name = "zr36016";
363                 break;
364         default:
365                 break;
366         }
367
368         return name;
369 }
370
371 // struct tvnorm {
372 //      u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
373 // };
374
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 };
379
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 };
382
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 };
386
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 };
392
393 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
394         {
395                 .type = DC10_old,
396                 .name = "DC10(old)",
397                 .i2c_decoder = I2C_DRIVERID_VPX3220,
398                 /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/
399                 .video_codec = CODEC_TYPE_ZR36050,
400                 .video_vfe = CODEC_TYPE_ZR36016,
401
402                 .inputs = 3,
403                 .input = {
404                         { 1, "Composite" },
405                         { 2, "S-Video" },
406                         { 0, "Internal/comp" }
407                 },
408                 .norms = 3,
409                 .tvn = {
410                         &f50sqpixel_dc10,
411                         &f60sqpixel_dc10,
412                         &f50sqpixel_dc10
413                 },
414                 .jpeg_int = 0,
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 },
418                 .gpcs = { -1, 0 },
419                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
420                 .gws_not_connected = 0,
421                 .init = &dc10_init,
422         }, {
423                 .type = DC10_new,
424                 .name = "DC10(new)",
425                 .i2c_decoder = I2C_DRIVERID_SAA7110,
426                 .i2c_encoder = I2C_DRIVERID_ADV7175,
427                 .video_codec = CODEC_TYPE_ZR36060,
428
429                 .inputs = 3,
430                 .input = {
431                                 { 0, "Composite" },
432                                 { 7, "S-Video" },
433                                 { 5, "Internal/comp" }
434                         },
435                 .norms = 3,
436                 .tvn = {
437                                 &f50sqpixel,
438                                 &f60sqpixel,
439                                 &f50sqpixel},
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 },
444                 .gpcs = { -1, 1},
445                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
446                 .gws_not_connected = 0,
447                 .init = &dc10plus_init,
448         }, {
449                 .type = DC10plus,
450                 .name = "DC10plus",
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,
456
457                 .inputs = 3,
458                 .input = {
459                         { 0, "Composite" },
460                         { 7, "S-Video" },
461                         { 5, "Internal/comp" }
462                 },
463                 .norms = 3,
464                 .tvn = {
465                         &f50sqpixel,
466                         &f60sqpixel,
467                         &f50sqpixel
468                 },
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 },
473                 .gpcs = { -1, 1 },
474                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
475                 .gws_not_connected = 0,
476                 .init = &dc10plus_init,
477         }, {
478                 .type = DC30,
479                 .name = "DC30",
480                 .i2c_decoder = I2C_DRIVERID_VPX3220,
481                 .i2c_encoder = I2C_DRIVERID_ADV7175,
482                 .video_codec = CODEC_TYPE_ZR36050,
483                 .video_vfe = CODEC_TYPE_ZR36016,
484
485                 .inputs = 3,
486                 .input = {
487                         { 1, "Composite" },
488                         { 2, "S-Video" },
489                         { 0, "Internal/comp" }
490                 },
491                 .norms = 3,
492                 .tvn = {
493                         &f50sqpixel_dc10,
494                         &f60sqpixel_dc10,
495                         &f50sqpixel_dc10
496                 },
497                 .jpeg_int = 0,
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 },
501                 .gpcs = { -1, 0 },
502                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
503                 .gws_not_connected = 0,
504                 .init = &dc10_init,
505         }, {
506                 .type = DC30plus,
507                 .name = "DC30plus",
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,
514
515                 .inputs = 3,
516                 .input = {
517                         { 1, "Composite" },
518                         { 2, "S-Video" },
519                         { 0, "Internal/comp" }
520                 },
521                 .norms = 3,
522                 .tvn = {
523                         &f50sqpixel_dc10,
524                         &f60sqpixel_dc10,
525                         &f50sqpixel_dc10
526                 },
527                 .jpeg_int = 0,
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 },
531                 .gpcs = { -1, 0 },
532                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
533                 .gws_not_connected = 0,
534                 .init = &dc10_init,
535         }, {
536                 .type = LML33,
537                 .name = "LML33",
538                 .i2c_decoder = I2C_DRIVERID_BT819,
539                 .i2c_encoder = I2C_DRIVERID_BT856,
540                 .video_codec = CODEC_TYPE_ZR36060,
541
542                 .inputs = 2,
543                 .input = {
544                         { 0, "Composite" },
545                         { 7, "S-Video" }
546                 },
547                 .norms = 2,
548                 .tvn = {
549                         &f50ccir601_lml33,
550                         &f60ccir601_lml33,
551                         NULL
552                 },
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 },
557                 .gpcs = { 3, 1 },
558                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
559                 .gws_not_connected = 1,
560                 .init = &lml33_init,
561         }, {
562                 .type = LML33R10,
563                 .name = "LML33R10",
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,
569
570                 .inputs = 2,
571                 .input = {
572                         { 0, "Composite" },
573                         { 7, "S-Video" }
574                 },
575                 .norms = 2,
576                 .tvn = {
577                         &f50ccir601_lm33r10,
578                         &f60ccir601_lm33r10,
579                         NULL
580                 },
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 },
585                 .gpcs = { 3, 1 },
586                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
587                 .gws_not_connected = 1,
588                 .init = &lml33_init,
589         }, {
590                 .type = BUZ,
591                 .name = "Buz",
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,
597
598                 .inputs = 2,
599                 .input = {
600                         { 3, "Composite" },
601                         { 7, "S-Video" }
602                 },
603                 .norms = 3,
604                 .tvn = {
605                         &f50ccir601,
606                         &f60ccir601,
607                         &f50ccir601
608                 },
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 },
613                 .gpcs = { 3, 1 },
614                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
615                 .gws_not_connected = 1,
616                 .init = &buz_init,
617         }
618 };
619
620 /*
621  * I2C functions
622  */
623 /* software I2C functions */
624 static int
625 zoran_i2c_getsda (void *data)
626 {
627         struct zoran *zr = (struct zoran *) data;
628
629         return (btread(ZR36057_I2CBR) >> 1) & 1;
630 }
631
632 static int
633 zoran_i2c_getscl (void *data)
634 {
635         struct zoran *zr = (struct zoran *) data;
636
637         return btread(ZR36057_I2CBR) & 1;
638 }
639
640 static void
641 zoran_i2c_setsda (void *data,
642                   int   state)
643 {
644         struct zoran *zr = (struct zoran *) data;
645
646         if (state)
647                 zr->i2cbr |= 2;
648         else
649                 zr->i2cbr &= ~2;
650         btwrite(zr->i2cbr, ZR36057_I2CBR);
651 }
652
653 static void
654 zoran_i2c_setscl (void *data,
655                   int   state)
656 {
657         struct zoran *zr = (struct zoran *) data;
658
659         if (state)
660                 zr->i2cbr |= 1;
661         else
662                 zr->i2cbr &= ~1;
663         btwrite(zr->i2cbr, ZR36057_I2CBR);
664 }
665
666 static int
667 zoran_i2c_client_register (struct i2c_client *client)
668 {
669         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
670         int res = 0;
671
672         dprintk(2,
673                 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
674                 ZR_DEVNAME(zr), client->driver->id);
675
676         down(&zr->resource_lock);
677
678         if (zr->user > 0) {
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?)
682                  */
683                 res = -EBUSY;
684                 goto clientreg_unlock_and_return;
685         }
686
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;
691         else {
692                 res = -ENODEV;
693                 goto clientreg_unlock_and_return;
694         }
695
696 clientreg_unlock_and_return:
697         up(&zr->resource_lock);
698
699         return res;
700 }
701
702 static int
703 zoran_i2c_client_unregister (struct i2c_client *client)
704 {
705         struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
706         int res = 0;
707
708         dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
709
710         down(&zr->resource_lock);
711
712         if (zr->user > 0) {
713                 res = -EBUSY;
714                 goto clientunreg_unlock_and_return;
715         }
716
717         /* try to locate it */
718         if (client == zr->encoder) {
719                 zr->encoder = NULL;
720         } else if (client == zr->decoder) {
721                 zr->decoder = NULL;
722                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
723         }
724 clientunreg_unlock_and_return:
725         up(&zr->resource_lock);
726         return res;
727 }
728
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,
734         .udelay = 10,
735         .mdelay = 0,
736         .timeout = 100,
737 };
738
739 static struct i2c_adapter zoran_i2c_adapter_template = {
740         .name = "zr36057",
741         .id = I2C_HW_B_ZR36067,
742         .algo = NULL,
743         .client_register = zoran_i2c_client_register,
744         .client_unregister = zoran_i2c_client_unregister,
745 };
746
747 static int
748 zoran_register_i2c (struct zoran *zr)
749 {
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);
760 }
761
762 static void
763 zoran_unregister_i2c (struct zoran *zr)
764 {
765         i2c_bit_del_bus((&zr->i2c_adapter));
766 }
767
768 /* Check a zoran_params struct for correctness, insert default params */
769
770 int
771 zoran_check_jpg_settings (struct zoran              *zr,
772                           struct zoran_jpg_settings *settings)
773 {
774         int err = 0, err0 = 0;
775
776         dprintk(4,
777                 KERN_DEBUG
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);
781         dprintk(4,
782                 KERN_DEBUG
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) {
788         case 1:
789
790                 settings->HorDcm = 1;
791                 settings->VerDcm = 1;
792                 settings->TmpDcm = 1;
793                 settings->field_per_buff = 2;
794                 settings->img_x = 0;
795                 settings->img_y = 0;
796                 settings->img_width = BUZ_MAX_WIDTH;
797                 settings->img_height = BUZ_MAX_HEIGHT / 2;
798                 break;
799         case 2:
800
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;
806                 settings->img_y = 0;
807                 settings->img_width =
808                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
809                 settings->img_height = BUZ_MAX_HEIGHT / 2;
810                 break;
811         case 4:
812
813                 if (zr->card.type == DC10_new) {
814                         dprintk(1,
815                                 KERN_DEBUG
816                                 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
817                                 ZR_DEVNAME(zr));
818                         err0++;
819                         break;
820                 }
821
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;
827                 settings->img_y = 0;
828                 settings->img_width =
829                     (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
830                 settings->img_height = BUZ_MAX_HEIGHT / 2;
831                 break;
832         case 0:
833
834                 /* We have to check the data the user has set */
835
836                 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
837                     (zr->card.type == DC10_new || settings->HorDcm != 4))
838                         err0++;
839                 if (settings->VerDcm != 1 && settings->VerDcm != 2)
840                         err0++;
841                 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
842                         err0++;
843                 if (settings->field_per_buff != 1 &&
844                     settings->field_per_buff != 2)
845                         err0++;
846                 if (settings->img_x < 0)
847                         err0++;
848                 if (settings->img_y < 0)
849                         err0++;
850                 if (settings->img_width < 0)
851                         err0++;
852                 if (settings->img_height < 0)
853                         err0++;
854                 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
855                         err0++;
856                 if (settings->img_y + settings->img_height >
857                     BUZ_MAX_HEIGHT / 2)
858                         err0++;
859                 if (settings->HorDcm && settings->VerDcm) {
860                         if (settings->img_width %
861                             (16 * settings->HorDcm) != 0)
862                                 err0++;
863                         if (settings->img_height %
864                             (8 * settings->VerDcm) != 0)
865                                 err0++;
866                 }
867
868                 if (err0) {
869                         dprintk(1,
870                                 KERN_ERR
871                                 "%s: check_jpg_settings() - error in params for decimation = 0\n",
872                                 ZR_DEVNAME(zr));
873                         err++;
874                 }
875                 break;
876         default:
877                 dprintk(1,
878                         KERN_ERR
879                         "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
880                         ZR_DEVNAME(zr), settings->decimation);
881                 err++;
882                 break;
883         }
884
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;
901         if (err)
902                 return -EINVAL;
903         return 0;
904 }
905
906 void
907 zoran_open_init_params (struct zoran *zr)
908 {
909         int i;
910
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;
915
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);
926
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 */
934         }
935         zr->v4l_buffers.allocated = 0;
936
937         for (i = 0; i < BUZ_MAX_FRAME; i++) {
938                 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER;       /* nothing going on */
939         }
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;
947         else
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);
959         if (i)
960                 dprintk(1,
961                         KERN_ERR
962                         "%s: zoran_open_init_params() internal error\n",
963                         ZR_DEVNAME(zr));
964
965         clear_interrupt_counters(zr);
966         zr->testing = 0;
967 }
968
969 static void __devinit
970 test_interrupts (struct zoran *zr)
971 {
972         DEFINE_WAIT(wait);
973         int timeout, icr;
974
975         clear_interrupt_counters(zr);
976
977         zr->testing = 1;
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);
985         zr->testing = 0;
986         dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
987         if (timeout) {
988                 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
989         }
990         if (*zr_debug > 1)
991                 print_interrupts(zr);
992         btwrite(icr, ZR36057_ICR);
993 }
994
995 static int __devinit
996 zr36057_init (struct zoran *zr)
997 {
998         u32 *mem;
999         void *vdev;
1000         unsigned mem_needed;
1001         int j;
1002         int two = 2;
1003         int zero = 0;
1004
1005         dprintk(1,
1006                 KERN_INFO
1007                 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1008                 ZR_DEVNAME(zr), zr->id, zr);
1009
1010         /* default setup of all parameters which will persist between opens */
1011         zr->user = 0;
1012
1013         init_waitqueue_head(&zr->v4l_capq);
1014         init_waitqueue_head(&zr->jpg_capq);
1015         init_waitqueue_head(&zr->test_q);
1016         zr->jpg_buffers.allocated = 0;
1017         zr->v4l_buffers.allocated = 0;
1018
1019         zr->buffer.base = (void *) vidmem;
1020         zr->buffer.width = 0;
1021         zr->buffer.height = 0;
1022         zr->buffer.depth = 0;
1023         zr->buffer.bytesperline = 0;
1024
1025         /* Avoid nonsense settings from user for default input/norm */
1026         if (default_norm < VIDEO_MODE_PAL &&
1027             default_norm > VIDEO_MODE_SECAM)
1028                 default_norm = VIDEO_MODE_PAL;
1029         zr->norm = default_norm;
1030         if (!(zr->timing = zr->card.tvn[zr->norm])) {
1031                 dprintk(1,
1032                         KERN_WARNING
1033                         "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1034                         ZR_DEVNAME(zr));
1035                 zr->norm = VIDEO_MODE_PAL;
1036                 zr->timing = zr->card.tvn[zr->norm];
1037         }
1038
1039         zr->input = default_input = (default_input ? 1 : 0);
1040
1041         /* Should the following be reset at every open ? */
1042         zr->hue = 32768;
1043         zr->contrast = 32768;
1044         zr->saturation = 32768;
1045         zr->brightness = 32768;
1046
1047         /* default setup (will be repeated at every open) */
1048         zoran_open_init_params(zr);
1049
1050         /* allocate memory *before* doing anything to the hardware
1051          * in case allocation fails */
1052         mem_needed = BUZ_NUM_STAT_COM * 4;
1053         mem = kzalloc(mem_needed, GFP_KERNEL);
1054         vdev = (void *) kmalloc(sizeof(struct video_device), GFP_KERNEL);
1055         if (!mem || !vdev) {
1056                 dprintk(1,
1057                         KERN_ERR
1058                         "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1059                         ZR_DEVNAME(zr));
1060                 kfree(vdev);
1061                 kfree(mem);
1062                 return -ENOMEM;
1063         }
1064         zr->stat_com = mem;
1065         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1066                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
1067         }
1068
1069         /*
1070          *   Now add the template and register the device unit.
1071          */
1072         zr->video_dev = vdev;
1073         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1074         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1075         if (video_register_device(zr->video_dev, VFL_TYPE_GRABBER,
1076                                   video_nr) < 0) {
1077                 zoran_unregister_i2c(zr);
1078                 kfree((void *) zr->stat_com);
1079                 kfree(vdev);
1080                 return -1;
1081         }
1082
1083         zoran_init_hardware(zr);
1084         if (*zr_debug > 2)
1085                 detect_guest_activity(zr);
1086         test_interrupts(zr);
1087         if (!pass_through) {
1088                 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1089                 encoder_command(zr, ENCODER_SET_INPUT, &two);
1090         }
1091
1092         zr->zoran_proc = NULL;
1093         zr->initialized = 1;
1094         return 0;
1095 }
1096
1097 static void
1098 zoran_release (struct zoran *zr)
1099 {
1100         if (!zr->initialized)
1101                 return;
1102         /* unregister videocodec bus */
1103         if (zr->codec) {
1104                 struct videocodec_master *master = zr->codec->master_data;
1105
1106                 videocodec_detach(zr->codec);
1107                 kfree(master);
1108         }
1109         if (zr->vfe) {
1110                 struct videocodec_master *master = zr->vfe->master_data;
1111
1112                 videocodec_detach(zr->vfe);
1113                 kfree(master);
1114         }
1115
1116         /* unregister i2c bus */
1117         zoran_unregister_i2c(zr);
1118         /* disable PCI bus-mastering */
1119         zoran_set_pci_master(zr, 0);
1120         /* put chip into reset */
1121         btwrite(0, ZR36057_SPGPPCR);
1122         free_irq(zr->pci_dev->irq, zr);
1123         /* unmap and free memory */
1124         kfree((void *) zr->stat_com);
1125         zoran_proc_cleanup(zr);
1126         iounmap(zr->zr36057_mem);
1127         pci_disable_device(zr->pci_dev);
1128         video_unregister_device(zr->video_dev);
1129 }
1130
1131 void
1132 zoran_vdev_release (struct video_device *vdev)
1133 {
1134         kfree(vdev);
1135 }
1136
1137 static struct videocodec_master * __devinit
1138 zoran_setup_videocodec (struct zoran *zr,
1139                         int           type)
1140 {
1141         struct videocodec_master *m = NULL;
1142
1143         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1144         if (!m) {
1145                 dprintk(1,
1146                         KERN_ERR
1147                         "%s: zoran_setup_videocodec() - no memory\n",
1148                         ZR_DEVNAME(zr));
1149                 return m;
1150         }
1151
1152         m->magic = 0L; /* magic not used */
1153         m->type = VID_HARDWARE_ZR36067;
1154         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1155         strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1156         m->data = zr;
1157
1158         switch (type)
1159         {
1160         case CODEC_TYPE_ZR36060:
1161                 m->readreg = zr36060_read;
1162                 m->writereg = zr36060_write;
1163                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1164                 break;
1165         case CODEC_TYPE_ZR36050:
1166                 m->readreg = zr36050_read;
1167                 m->writereg = zr36050_write;
1168                 m->flags |= CODEC_FLAG_JPEG;
1169                 break;
1170         case CODEC_TYPE_ZR36016:
1171                 m->readreg = zr36016_read;
1172                 m->writereg = zr36016_write;
1173                 m->flags |= CODEC_FLAG_VFE;
1174                 break;
1175         }
1176
1177         return m;
1178 }
1179
1180 /*
1181  *   Scan for a Buz card (actually for the PCI contoler ZR36057),
1182  *   request the irq and map the io memory
1183  */
1184 static int __devinit
1185 find_zr36057 (void)
1186 {
1187         unsigned char latency, need_latency;
1188         struct zoran *zr;
1189         struct pci_dev *dev = NULL;
1190         int result;
1191         struct videocodec_master *master_vfe = NULL;
1192         struct videocodec_master *master_codec = NULL;
1193         int card_num;
1194         char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1195
1196         zoran_num = 0;
1197         while (zoran_num < BUZ_MAX &&
1198                (dev =
1199                 pci_find_device(PCI_VENDOR_ID_ZORAN,
1200                                 PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1201                 card_num = card[zoran_num];
1202                 zr = &zoran[zoran_num];
1203                 memset(zr, 0, sizeof(struct zoran));    // Just in case if previous cycle failed
1204                 zr->pci_dev = dev;
1205                 //zr->zr36057_mem = NULL;
1206                 zr->id = zoran_num;
1207                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1208                 spin_lock_init(&zr->spinlock);
1209                 init_MUTEX(&zr->resource_lock);
1210                 if (pci_enable_device(dev))
1211                         continue;
1212                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1213                 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1214                                      &zr->revision);
1215                 if (zr->revision < 2) {
1216                         dprintk(1,
1217                                 KERN_INFO
1218                                 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1219                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1220                                 zr->zr36057_adr);
1221
1222                         if (card_num == -1) {
1223                                 dprintk(1,
1224                                         KERN_ERR
1225                                         "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1226                                         ZR_DEVNAME(zr));
1227                                 continue;
1228                         }
1229                 } else {
1230                         int i;
1231                         unsigned short ss_vendor, ss_device;
1232
1233                         ss_vendor = zr->pci_dev->subsystem_vendor;
1234                         ss_device = zr->pci_dev->subsystem_device;
1235                         dprintk(1,
1236                                 KERN_INFO
1237                                 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1238                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1239                                 zr->zr36057_adr);
1240                         dprintk(1,
1241                                 KERN_INFO
1242                                 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1243                                 ZR_DEVNAME(zr), ss_vendor, ss_device);
1244                         if (card_num == -1) {
1245                                 dprintk(3,
1246                                         KERN_DEBUG
1247                                         "%s: find_zr36057() - trying to autodetect card type\n",
1248                                         ZR_DEVNAME(zr));
1249                                 for (i=0;i<NUM_CARDS;i++) {
1250                                         if (ss_vendor == zoran_cards[i].vendor_id &&
1251                                             ss_device == zoran_cards[i].device_id) {
1252                                                 dprintk(3,
1253                                                         KERN_DEBUG
1254                                                         "%s: find_zr36057() - card %s detected\n",
1255                                                         ZR_DEVNAME(zr),
1256                                                         zoran_cards[i].name);
1257                                                 card_num = i;
1258                                                 break;
1259                                         }
1260                                 }
1261                                 if (i == NUM_CARDS) {
1262                                         dprintk(1,
1263                                                 KERN_ERR
1264                                                 "%s: find_zr36057() - unknown card\n",
1265                                                 ZR_DEVNAME(zr));
1266                                         continue;
1267                                 }
1268                         }
1269                 }
1270
1271                 if (card_num < 0 || card_num >= NUM_CARDS) {
1272                         dprintk(2,
1273                                 KERN_ERR
1274                                 "%s: find_zr36057() - invalid cardnum %d\n",
1275                                 ZR_DEVNAME(zr), card_num);
1276                         continue;
1277                 }
1278
1279                 /* even though we make this a non pointer and thus
1280                  * theoretically allow for making changes to this struct
1281                  * on a per-individual card basis at runtime, this is
1282                  * strongly discouraged. This structure is intended to
1283                  * keep general card information, no settings or anything */
1284                 zr->card = zoran_cards[card_num];
1285                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1286                          "%s[%u]", zr->card.name, zr->id);
1287
1288                 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1289                 if (!zr->zr36057_mem) {
1290                         dprintk(1,
1291                                 KERN_ERR
1292                                 "%s: find_zr36057() - ioremap failed\n",
1293                                 ZR_DEVNAME(zr));
1294                         continue;
1295                 }
1296
1297                 result = request_irq(zr->pci_dev->irq,
1298                                      zoran_irq,
1299                                      SA_SHIRQ | SA_INTERRUPT,
1300                                      ZR_DEVNAME(zr),
1301                                      (void *) zr);
1302                 if (result < 0) {
1303                         if (result == -EINVAL) {
1304                                 dprintk(1,
1305                                         KERN_ERR
1306                                         "%s: find_zr36057() - bad irq number or handler\n",
1307                                         ZR_DEVNAME(zr));
1308                         } else if (result == -EBUSY) {
1309                                 dprintk(1,
1310                                         KERN_ERR
1311                                         "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1312                                         ZR_DEVNAME(zr), zr->pci_dev->irq);
1313                         } else {
1314                                 dprintk(1,
1315                                         KERN_ERR
1316                                         "%s: find_zr36057() - can't assign irq, error code %d\n",
1317                                         ZR_DEVNAME(zr), result);
1318                         }
1319                         goto zr_unmap;
1320                 }
1321
1322                 /* set PCI latency timer */
1323                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1324                                      &latency);
1325                 need_latency = zr->revision > 1 ? 32 : 48;
1326                 if (latency != need_latency) {
1327                         dprintk(2,
1328                                 KERN_INFO
1329                                 "%s: Changing PCI latency from %d to %d.\n",
1330                                 ZR_DEVNAME(zr), latency, need_latency);
1331                         pci_write_config_byte(zr->pci_dev,
1332                                               PCI_LATENCY_TIMER,
1333                                               need_latency);
1334                 }
1335
1336                 zr36057_restart(zr);
1337                 /* i2c */
1338                 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1339                         ZR_DEVNAME(zr));
1340
1341                 /* i2c decoder */
1342                 if (decoder[zr->id] != -1) {
1343                         i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1344                         zr->card.i2c_decoder = decoder[zr->id];
1345                 } else if (zr->card.i2c_decoder != 0) {
1346                         i2c_dec_name =
1347                                 i2cid_to_modulename(zr->card.i2c_decoder);
1348                 } else {
1349                         i2c_dec_name = NULL;
1350                 }
1351
1352                 if (i2c_dec_name) {
1353                         if ((result = request_module(i2c_dec_name)) < 0) {
1354                                 dprintk(1,
1355                                         KERN_ERR
1356                                         "%s: failed to load module %s: %d\n",
1357                                         ZR_DEVNAME(zr), i2c_dec_name, result);
1358                         }
1359                 }
1360
1361                 /* i2c encoder */
1362                 if (encoder[zr->id] != -1) {
1363                         i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1364                         zr->card.i2c_encoder = encoder[zr->id];
1365                 } else if (zr->card.i2c_encoder != 0) {
1366                         i2c_enc_name =
1367                                 i2cid_to_modulename(zr->card.i2c_encoder);
1368                 } else {
1369                         i2c_enc_name = NULL;
1370                 }
1371
1372                 if (i2c_enc_name) {
1373                         if ((result = request_module(i2c_enc_name)) < 0) {
1374                                 dprintk(1,
1375                                         KERN_ERR
1376                                         "%s: failed to load module %s: %d\n",
1377                                         ZR_DEVNAME(zr), i2c_enc_name, result);
1378                         }
1379                 }
1380
1381                 if (zoran_register_i2c(zr) < 0) {
1382                         dprintk(1,
1383                                 KERN_ERR
1384                                 "%s: find_zr36057() - can't initialize i2c bus\n",
1385                                 ZR_DEVNAME(zr));
1386                         goto zr_free_irq;
1387                 }
1388
1389                 dprintk(2,
1390                         KERN_INFO "%s: Initializing videocodec bus...\n",
1391                         ZR_DEVNAME(zr));
1392
1393                 if (zr->card.video_codec != 0 &&
1394                     (codec_name =
1395                      codecid_to_modulename(zr->card.video_codec)) != NULL) {
1396                         if ((result = request_module(codec_name)) < 0) {
1397                                 dprintk(1,
1398                                         KERN_ERR
1399                                         "%s: failed to load modules %s: %d\n",
1400                                         ZR_DEVNAME(zr), codec_name, result);
1401                         }
1402                 }
1403                 if (zr->card.video_vfe != 0 &&
1404                     (vfe_name =
1405                      codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1406                         if ((result = request_module(vfe_name)) < 0) {
1407                                 dprintk(1,
1408                                         KERN_ERR
1409                                         "%s: failed to load modules %s: %d\n",
1410                                         ZR_DEVNAME(zr), vfe_name, result);
1411                         }
1412                 }
1413
1414                 /* reset JPEG codec */
1415                 jpeg_codec_sleep(zr, 1);
1416                 jpeg_codec_reset(zr);
1417                 /* video bus enabled */
1418                 /* display codec revision */
1419                 if (zr->card.video_codec != 0) {
1420                         master_codec = zoran_setup_videocodec(zr,
1421                                                               zr->card.video_codec);
1422                         if (!master_codec)
1423                                 goto zr_unreg_i2c;
1424                         zr->codec = videocodec_attach(master_codec);
1425                         if (!zr->codec) {
1426                                 dprintk(1,
1427                                         KERN_ERR
1428                                         "%s: find_zr36057() - no codec found\n",
1429                                         ZR_DEVNAME(zr));
1430                                 goto zr_free_codec;
1431                         }
1432                         if (zr->codec->type != zr->card.video_codec) {
1433                                 dprintk(1,
1434                                         KERN_ERR
1435                                         "%s: find_zr36057() - wrong codec\n",
1436                                         ZR_DEVNAME(zr));
1437                                 goto zr_detach_codec;
1438                         }
1439                 }
1440                 if (zr->card.video_vfe != 0) {
1441                         master_vfe = zoran_setup_videocodec(zr,
1442                                                             zr->card.video_vfe);
1443                         if (!master_vfe)
1444                                 goto zr_detach_codec;
1445                         zr->vfe = videocodec_attach(master_vfe);
1446                         if (!zr->vfe) {
1447                                 dprintk(1,
1448                                         KERN_ERR
1449                                         "%s: find_zr36057() - no VFE found\n",
1450                                         ZR_DEVNAME(zr));
1451                                 goto zr_free_vfe;
1452                         }
1453                         if (zr->vfe->type != zr->card.video_vfe) {
1454                                 dprintk(1,
1455                                         KERN_ERR
1456                                         "%s: find_zr36057() = wrong VFE\n",
1457                                         ZR_DEVNAME(zr));
1458                                 goto zr_detach_vfe;
1459                         }
1460                 }
1461
1462                 zoran_num++;
1463                 continue;
1464
1465                 // Init errors
1466               zr_detach_vfe:
1467                 videocodec_detach(zr->vfe);
1468               zr_free_vfe:
1469                 kfree(master_vfe);
1470               zr_detach_codec:
1471                 videocodec_detach(zr->codec);
1472               zr_free_codec:
1473                 kfree(master_codec);
1474               zr_unreg_i2c:
1475                 zoran_unregister_i2c(zr);
1476               zr_free_irq:
1477                 btwrite(0, ZR36057_SPGPPCR);
1478                 free_irq(zr->pci_dev->irq, zr);
1479               zr_unmap:
1480                 iounmap(zr->zr36057_mem);
1481                 continue;
1482         }
1483         if (zoran_num == 0) {
1484                 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1485         }
1486         return zoran_num;
1487 }
1488
1489 static int __init
1490 init_dc10_cards (void)
1491 {
1492         int i;
1493
1494         memset(zoran, 0, sizeof(zoran));
1495         printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1496                MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1497
1498         /* Look for cards */
1499         if (find_zr36057() < 0) {
1500                 return -EIO;
1501         }
1502         if (zoran_num == 0)
1503                 return -ENODEV;
1504         dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1505                 zoran_num);
1506         /* check the parameters we have been given, adjust if necessary */
1507         if (v4l_nbufs < 2)
1508                 v4l_nbufs = 2;
1509         if (v4l_nbufs > VIDEO_MAX_FRAME)
1510                 v4l_nbufs = VIDEO_MAX_FRAME;
1511         /* The user specfies the in KB, we want them in byte
1512          * (and page aligned) */
1513         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1514         if (v4l_bufsize < 32768)
1515                 v4l_bufsize = 32768;
1516         /* 2 MB is arbitrary but sufficient for the maximum possible images */
1517         if (v4l_bufsize > 2048 * 1024)
1518                 v4l_bufsize = 2048 * 1024;
1519         if (jpg_nbufs < 4)
1520                 jpg_nbufs = 4;
1521         if (jpg_nbufs > BUZ_MAX_FRAME)
1522                 jpg_nbufs = BUZ_MAX_FRAME;
1523         jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1524         if (jpg_bufsize < 8192)
1525                 jpg_bufsize = 8192;
1526         if (jpg_bufsize > (512 * 1024))
1527                 jpg_bufsize = 512 * 1024;
1528         /* Use parameter for vidmem or try to find a video card */
1529         if (vidmem) {
1530                 dprintk(1,
1531                         KERN_INFO
1532                         "%s: Using supplied video memory base address @ 0x%lx\n",
1533                         ZORAN_NAME, vidmem);
1534         }
1535
1536         /* random nonsense */
1537         dprintk(5, KERN_DEBUG "Jotti is een held!\n");
1538
1539         /* some mainboards might not do PCI-PCI data transfer well */
1540         if (pci_pci_problems & PCIPCI_FAIL) {
1541                 dprintk(1,
1542                         KERN_WARNING
1543                         "%s: chipset may not support reliable PCI-PCI DMA\n",
1544                         ZORAN_NAME);
1545         }
1546
1547         /* take care of Natoma chipset and a revision 1 zr36057 */
1548         for (i = 0; i < zoran_num; i++) {
1549                 struct zoran *zr = &zoran[i];
1550
1551                 if (pci_pci_problems & PCIPCI_NATOMA && zr->revision <= 1) {
1552                         zr->jpg_buffers.need_contiguous = 1;
1553                         dprintk(1,
1554                                 KERN_INFO
1555                                 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1556                                 ZR_DEVNAME(zr));
1557                 }
1558
1559                 if (zr36057_init(zr) < 0) {
1560                         for (i = 0; i < zoran_num; i++)
1561                                 zoran_release(&zoran[i]);
1562                         return -EIO;
1563                 }
1564                 zoran_proc_init(zr);
1565         }
1566
1567         return 0;
1568 }
1569
1570 static void __exit
1571 unload_dc10_cards (void)
1572 {
1573         int i;
1574
1575         for (i = 0; i < zoran_num; i++)
1576                 zoran_release(&zoran[i]);
1577 }
1578
1579 module_init(init_dc10_cards);
1580 module_exit(unload_dc10_cards);