[PATCH] kfree cleanup: drivers/media
[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         unsigned long 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 = (unsigned long) kmalloc(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((void *)mem);
1062                 return -ENOMEM;
1063         }
1064         memset((void *) mem, 0, mem_needed);
1065         zr->stat_com = (u32 *) mem;
1066         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1067                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
1068         }
1069
1070         /*
1071          *   Now add the template and register the device unit.
1072          */
1073         zr->video_dev = vdev;
1074         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1075         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1076         if (video_register_device(zr->video_dev, VFL_TYPE_GRABBER,
1077                                   video_nr) < 0) {
1078                 zoran_unregister_i2c(zr);
1079                 kfree((void *) zr->stat_com);
1080                 kfree(vdev);
1081                 return -1;
1082         }
1083
1084         zoran_init_hardware(zr);
1085         if (*zr_debug > 2)
1086                 detect_guest_activity(zr);
1087         test_interrupts(zr);
1088         if (!pass_through) {
1089                 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1090                 encoder_command(zr, ENCODER_SET_INPUT, &two);
1091         }
1092
1093         zr->zoran_proc = NULL;
1094         zr->initialized = 1;
1095         return 0;
1096 }
1097
1098 static void
1099 zoran_release (struct zoran *zr)
1100 {
1101         if (!zr->initialized)
1102                 return;
1103         /* unregister videocodec bus */
1104         if (zr->codec) {
1105                 struct videocodec_master *master = zr->codec->master_data;
1106
1107                 videocodec_detach(zr->codec);
1108                 kfree(master);
1109         }
1110         if (zr->vfe) {
1111                 struct videocodec_master *master = zr->vfe->master_data;
1112
1113                 videocodec_detach(zr->vfe);
1114                 kfree(master);
1115         }
1116
1117         /* unregister i2c bus */
1118         zoran_unregister_i2c(zr);
1119         /* disable PCI bus-mastering */
1120         zoran_set_pci_master(zr, 0);
1121         /* put chip into reset */
1122         btwrite(0, ZR36057_SPGPPCR);
1123         free_irq(zr->pci_dev->irq, zr);
1124         /* unmap and free memory */
1125         kfree((void *) zr->stat_com);
1126         zoran_proc_cleanup(zr);
1127         iounmap(zr->zr36057_mem);
1128         pci_disable_device(zr->pci_dev);
1129         video_unregister_device(zr->video_dev);
1130 }
1131
1132 void
1133 zoran_vdev_release (struct video_device *vdev)
1134 {
1135         kfree(vdev);
1136 }
1137
1138 static struct videocodec_master * __devinit
1139 zoran_setup_videocodec (struct zoran *zr,
1140                         int           type)
1141 {
1142         struct videocodec_master *m = NULL;
1143
1144         m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1145         if (!m) {
1146                 dprintk(1,
1147                         KERN_ERR
1148                         "%s: zoran_setup_videocodec() - no memory\n",
1149                         ZR_DEVNAME(zr));
1150                 return m;
1151         }
1152
1153         m->magic = 0L; /* magic not used */
1154         m->type = VID_HARDWARE_ZR36067;
1155         m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1156         strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1157         m->data = zr;
1158
1159         switch (type)
1160         {
1161         case CODEC_TYPE_ZR36060:
1162                 m->readreg = zr36060_read;
1163                 m->writereg = zr36060_write;
1164                 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1165                 break;
1166         case CODEC_TYPE_ZR36050:
1167                 m->readreg = zr36050_read;
1168                 m->writereg = zr36050_write;
1169                 m->flags |= CODEC_FLAG_JPEG;
1170                 break;
1171         case CODEC_TYPE_ZR36016:
1172                 m->readreg = zr36016_read;
1173                 m->writereg = zr36016_write;
1174                 m->flags |= CODEC_FLAG_VFE;
1175                 break;
1176         }
1177
1178         return m;
1179 }
1180
1181 /*
1182  *   Scan for a Buz card (actually for the PCI contoler ZR36057),
1183  *   request the irq and map the io memory
1184  */
1185 static int __devinit
1186 find_zr36057 (void)
1187 {
1188         unsigned char latency, need_latency;
1189         struct zoran *zr;
1190         struct pci_dev *dev = NULL;
1191         int result;
1192         struct videocodec_master *master_vfe = NULL;
1193         struct videocodec_master *master_codec = NULL;
1194         int card_num;
1195         char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1196
1197         zoran_num = 0;
1198         while (zoran_num < BUZ_MAX &&
1199                (dev =
1200                 pci_find_device(PCI_VENDOR_ID_ZORAN,
1201                                 PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1202                 card_num = card[zoran_num];
1203                 zr = &zoran[zoran_num];
1204                 memset(zr, 0, sizeof(struct zoran));    // Just in case if previous cycle failed
1205                 zr->pci_dev = dev;
1206                 //zr->zr36057_mem = NULL;
1207                 zr->id = zoran_num;
1208                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1209                 spin_lock_init(&zr->spinlock);
1210                 init_MUTEX(&zr->resource_lock);
1211                 if (pci_enable_device(dev))
1212                         continue;
1213                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1214                 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1215                                      &zr->revision);
1216                 if (zr->revision < 2) {
1217                         dprintk(1,
1218                                 KERN_INFO
1219                                 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1220                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1221                                 zr->zr36057_adr);
1222
1223                         if (card_num == -1) {
1224                                 dprintk(1,
1225                                         KERN_ERR
1226                                         "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1227                                         ZR_DEVNAME(zr));
1228                                 continue;
1229                         }
1230                 } else {
1231                         int i;
1232                         unsigned short ss_vendor, ss_device;
1233
1234                         ss_vendor = zr->pci_dev->subsystem_vendor;
1235                         ss_device = zr->pci_dev->subsystem_device;
1236                         dprintk(1,
1237                                 KERN_INFO
1238                                 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1239                                 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1240                                 zr->zr36057_adr);
1241                         dprintk(1,
1242                                 KERN_INFO
1243                                 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1244                                 ZR_DEVNAME(zr), ss_vendor, ss_device);
1245                         if (card_num == -1) {
1246                                 dprintk(3,
1247                                         KERN_DEBUG
1248                                         "%s: find_zr36057() - trying to autodetect card type\n",
1249                                         ZR_DEVNAME(zr));
1250                                 for (i=0;i<NUM_CARDS;i++) {
1251                                         if (ss_vendor == zoran_cards[i].vendor_id &&
1252                                             ss_device == zoran_cards[i].device_id) {
1253                                                 dprintk(3,
1254                                                         KERN_DEBUG
1255                                                         "%s: find_zr36057() - card %s detected\n",
1256                                                         ZR_DEVNAME(zr),
1257                                                         zoran_cards[i].name);
1258                                                 card_num = i;
1259                                                 break;
1260                                         }
1261                                 }
1262                                 if (i == NUM_CARDS) {
1263                                         dprintk(1,
1264                                                 KERN_ERR
1265                                                 "%s: find_zr36057() - unknown card\n",
1266                                                 ZR_DEVNAME(zr));
1267                                         continue;
1268                                 }
1269                         }
1270                 }
1271
1272                 if (card_num < 0 || card_num >= NUM_CARDS) {
1273                         dprintk(2,
1274                                 KERN_ERR
1275                                 "%s: find_zr36057() - invalid cardnum %d\n",
1276                                 ZR_DEVNAME(zr), card_num);
1277                         continue;
1278                 }
1279
1280                 /* even though we make this a non pointer and thus
1281                  * theoretically allow for making changes to this struct
1282                  * on a per-individual card basis at runtime, this is
1283                  * strongly discouraged. This structure is intended to
1284                  * keep general card information, no settings or anything */
1285                 zr->card = zoran_cards[card_num];
1286                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1287                          "%s[%u]", zr->card.name, zr->id);
1288
1289                 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1290                 if (!zr->zr36057_mem) {
1291                         dprintk(1,
1292                                 KERN_ERR
1293                                 "%s: find_zr36057() - ioremap failed\n",
1294                                 ZR_DEVNAME(zr));
1295                         continue;
1296                 }
1297
1298                 result = request_irq(zr->pci_dev->irq,
1299                                      zoran_irq,
1300                                      SA_SHIRQ | SA_INTERRUPT,
1301                                      ZR_DEVNAME(zr),
1302                                      (void *) zr);
1303                 if (result < 0) {
1304                         if (result == -EINVAL) {
1305                                 dprintk(1,
1306                                         KERN_ERR
1307                                         "%s: find_zr36057() - bad irq number or handler\n",
1308                                         ZR_DEVNAME(zr));
1309                         } else if (result == -EBUSY) {
1310                                 dprintk(1,
1311                                         KERN_ERR
1312                                         "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1313                                         ZR_DEVNAME(zr), zr->pci_dev->irq);
1314                         } else {
1315                                 dprintk(1,
1316                                         KERN_ERR
1317                                         "%s: find_zr36057() - can't assign irq, error code %d\n",
1318                                         ZR_DEVNAME(zr), result);
1319                         }
1320                         goto zr_unmap;
1321                 }
1322
1323                 /* set PCI latency timer */
1324                 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1325                                      &latency);
1326                 need_latency = zr->revision > 1 ? 32 : 48;
1327                 if (latency != need_latency) {
1328                         dprintk(2,
1329                                 KERN_INFO
1330                                 "%s: Changing PCI latency from %d to %d.\n",
1331                                 ZR_DEVNAME(zr), latency, need_latency);
1332                         pci_write_config_byte(zr->pci_dev,
1333                                               PCI_LATENCY_TIMER,
1334                                               need_latency);
1335                 }
1336
1337                 zr36057_restart(zr);
1338                 /* i2c */
1339                 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1340                         ZR_DEVNAME(zr));
1341
1342                 /* i2c decoder */
1343                 if (decoder[zr->id] != -1) {
1344                         i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1345                         zr->card.i2c_decoder = decoder[zr->id];
1346                 } else if (zr->card.i2c_decoder != 0) {
1347                         i2c_dec_name =
1348                                 i2cid_to_modulename(zr->card.i2c_decoder);
1349                 } else {
1350                         i2c_dec_name = NULL;
1351                 }
1352
1353                 if (i2c_dec_name) {
1354                         if ((result = request_module(i2c_dec_name)) < 0) {
1355                                 dprintk(1,
1356                                         KERN_ERR
1357                                         "%s: failed to load module %s: %d\n",
1358                                         ZR_DEVNAME(zr), i2c_dec_name, result);
1359                         }
1360                 }
1361
1362                 /* i2c encoder */
1363                 if (encoder[zr->id] != -1) {
1364                         i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1365                         zr->card.i2c_encoder = encoder[zr->id];
1366                 } else if (zr->card.i2c_encoder != 0) {
1367                         i2c_enc_name =
1368                                 i2cid_to_modulename(zr->card.i2c_encoder);
1369                 } else {
1370                         i2c_enc_name = NULL;
1371                 }
1372
1373                 if (i2c_enc_name) {
1374                         if ((result = request_module(i2c_enc_name)) < 0) {
1375                                 dprintk(1,
1376                                         KERN_ERR
1377                                         "%s: failed to load module %s: %d\n",
1378                                         ZR_DEVNAME(zr), i2c_enc_name, result);
1379                         }
1380                 }
1381
1382                 if (zoran_register_i2c(zr) < 0) {
1383                         dprintk(1,
1384                                 KERN_ERR
1385                                 "%s: find_zr36057() - can't initialize i2c bus\n",
1386                                 ZR_DEVNAME(zr));
1387                         goto zr_free_irq;
1388                 }
1389
1390                 dprintk(2,
1391                         KERN_INFO "%s: Initializing videocodec bus...\n",
1392                         ZR_DEVNAME(zr));
1393
1394                 if (zr->card.video_codec != 0 &&
1395                     (codec_name =
1396                      codecid_to_modulename(zr->card.video_codec)) != NULL) {
1397                         if ((result = request_module(codec_name)) < 0) {
1398                                 dprintk(1,
1399                                         KERN_ERR
1400                                         "%s: failed to load modules %s: %d\n",
1401                                         ZR_DEVNAME(zr), codec_name, result);
1402                         }
1403                 }
1404                 if (zr->card.video_vfe != 0 &&
1405                     (vfe_name =
1406                      codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1407                         if ((result = request_module(vfe_name)) < 0) {
1408                                 dprintk(1,
1409                                         KERN_ERR
1410                                         "%s: failed to load modules %s: %d\n",
1411                                         ZR_DEVNAME(zr), vfe_name, result);
1412                         }
1413                 }
1414
1415                 /* reset JPEG codec */
1416                 jpeg_codec_sleep(zr, 1);
1417                 jpeg_codec_reset(zr);
1418                 /* video bus enabled */
1419                 /* display codec revision */
1420                 if (zr->card.video_codec != 0) {
1421                         master_codec = zoran_setup_videocodec(zr,
1422                                                               zr->card.video_codec);
1423                         if (!master_codec)
1424                                 goto zr_unreg_i2c;
1425                         zr->codec = videocodec_attach(master_codec);
1426                         if (!zr->codec) {
1427                                 dprintk(1,
1428                                         KERN_ERR
1429                                         "%s: find_zr36057() - no codec found\n",
1430                                         ZR_DEVNAME(zr));
1431                                 goto zr_free_codec;
1432                         }
1433                         if (zr->codec->type != zr->card.video_codec) {
1434                                 dprintk(1,
1435                                         KERN_ERR
1436                                         "%s: find_zr36057() - wrong codec\n",
1437                                         ZR_DEVNAME(zr));
1438                                 goto zr_detach_codec;
1439                         }
1440                 }
1441                 if (zr->card.video_vfe != 0) {
1442                         master_vfe = zoran_setup_videocodec(zr,
1443                                                             zr->card.video_vfe);
1444                         if (!master_vfe)
1445                                 goto zr_detach_codec;
1446                         zr->vfe = videocodec_attach(master_vfe);
1447                         if (!zr->vfe) {
1448                                 dprintk(1,
1449                                         KERN_ERR
1450                                         "%s: find_zr36057() - no VFE found\n",
1451                                         ZR_DEVNAME(zr));
1452                                 goto zr_free_vfe;
1453                         }
1454                         if (zr->vfe->type != zr->card.video_vfe) {
1455                                 dprintk(1,
1456                                         KERN_ERR
1457                                         "%s: find_zr36057() = wrong VFE\n",
1458                                         ZR_DEVNAME(zr));
1459                                 goto zr_detach_vfe;
1460                         }
1461                 }
1462
1463                 zoran_num++;
1464                 continue;
1465
1466                 // Init errors
1467               zr_detach_vfe:
1468                 videocodec_detach(zr->vfe);
1469               zr_free_vfe:
1470                 kfree(master_vfe);
1471               zr_detach_codec:
1472                 videocodec_detach(zr->codec);
1473               zr_free_codec:
1474                 kfree(master_codec);
1475               zr_unreg_i2c:
1476                 zoran_unregister_i2c(zr);
1477               zr_free_irq:
1478                 btwrite(0, ZR36057_SPGPPCR);
1479                 free_irq(zr->pci_dev->irq, zr);
1480               zr_unmap:
1481                 iounmap(zr->zr36057_mem);
1482                 continue;
1483         }
1484         if (zoran_num == 0) {
1485                 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1486         }
1487         return zoran_num;
1488 }
1489
1490 static int __init
1491 init_dc10_cards (void)
1492 {
1493         int i;
1494
1495         memset(zoran, 0, sizeof(zoran));
1496         printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1497                MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1498
1499         /* Look for cards */
1500         if (find_zr36057() < 0) {
1501                 return -EIO;
1502         }
1503         if (zoran_num == 0)
1504                 return -ENODEV;
1505         dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1506                 zoran_num);
1507         /* check the parameters we have been given, adjust if necessary */
1508         if (v4l_nbufs < 2)
1509                 v4l_nbufs = 2;
1510         if (v4l_nbufs > VIDEO_MAX_FRAME)
1511                 v4l_nbufs = VIDEO_MAX_FRAME;
1512         /* The user specfies the in KB, we want them in byte
1513          * (and page aligned) */
1514         v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1515         if (v4l_bufsize < 32768)
1516                 v4l_bufsize = 32768;
1517         /* 2 MB is arbitrary but sufficient for the maximum possible images */
1518         if (v4l_bufsize > 2048 * 1024)
1519                 v4l_bufsize = 2048 * 1024;
1520         if (jpg_nbufs < 4)
1521                 jpg_nbufs = 4;
1522         if (jpg_nbufs > BUZ_MAX_FRAME)
1523                 jpg_nbufs = BUZ_MAX_FRAME;
1524         jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1525         if (jpg_bufsize < 8192)
1526                 jpg_bufsize = 8192;
1527         if (jpg_bufsize > (512 * 1024))
1528                 jpg_bufsize = 512 * 1024;
1529         /* Use parameter for vidmem or try to find a video card */
1530         if (vidmem) {
1531                 dprintk(1,
1532                         KERN_INFO
1533                         "%s: Using supplied video memory base address @ 0x%lx\n",
1534                         ZORAN_NAME, vidmem);
1535         }
1536
1537         /* random nonsense */
1538         dprintk(5, KERN_DEBUG "Jotti is een held!\n");
1539
1540         /* some mainboards might not do PCI-PCI data transfer well */
1541         if (pci_pci_problems & PCIPCI_FAIL) {
1542                 dprintk(1,
1543                         KERN_WARNING
1544                         "%s: chipset may not support reliable PCI-PCI DMA\n",
1545                         ZORAN_NAME);
1546         }
1547
1548         /* take care of Natoma chipset and a revision 1 zr36057 */
1549         for (i = 0; i < zoran_num; i++) {
1550                 struct zoran *zr = &zoran[i];
1551
1552                 if (pci_pci_problems & PCIPCI_NATOMA && zr->revision <= 1) {
1553                         zr->jpg_buffers.need_contiguous = 1;
1554                         dprintk(1,
1555                                 KERN_INFO
1556                                 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1557                                 ZR_DEVNAME(zr));
1558                 }
1559
1560                 if (zr36057_init(zr) < 0) {
1561                         for (i = 0; i < zoran_num; i++)
1562                                 zoran_release(&zoran[i]);
1563                         return -EIO;
1564                 }
1565                 zoran_proc_init(zr);
1566         }
1567
1568         return 0;
1569 }
1570
1571 static void __exit
1572 unload_dc10_cards (void)
1573 {
1574         int i;
1575
1576         for (i = 0; i < zoran_num; i++)
1577                 zoran_release(&zoran[i]);
1578 }
1579
1580 module_init(init_dc10_cards);
1581 module_exit(unload_dc10_cards);