?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PRCM: 34XX: Fix wrong shift value used in dpll4_m4x2_ck enable bit
[linux-ginger.git] / drivers / media / video / zoran_card.c
blob006d48847e24a90396c0cfdaf29ad83554746a34
1 /*
2 * Zoran zr36057/zr36067 PCI controller driver, for the
3 * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
4 * Media Labs LML33/LML33R10.
5 *
6 * This part handles card-specific data and detection
7 *
8 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
9 *
10 * Currently maintained by:
11 * Ronald Bultje <rbultje@ronald.bitfreak.net>
12 * Laurent Pinchart <laurent.pinchart@skynet.be>
13 * Mailinglist <mjpeg-users@lists.sf.net>
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 */
29
30 #include <linux/delay.h>
31
32 #include <linux/types.h>
33 #include <linux/kernel.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/vmalloc.h>
37
38 #include <linux/proc_fs.h>
39 #include <linux/i2c.h>
40 #include <linux/i2c-algo-bit.h>
41 #include <linux/videodev.h>
42 #include <media/v4l2-common.h>
43 #include <linux/spinlock.h>
44 #include <linux/sem.h>
45 #include <linux/kmod.h>
46 #include <linux/wait.h>
47
48 #include <linux/pci.h>
49 #include <linux/interrupt.h>
50 #include <linux/video_decoder.h>
51 #include <linux/video_encoder.h>
52 #include <linux/mutex.h>
53
54 #include <asm/io.h>
55
56 #include "videocodec.h"
57 #include "zoran.h"
58 #include "zoran_card.h"
59 #include "zoran_device.h"
60 #include "zoran_procfs.h"
61
62 #define I2C_NAME(x) (x)->name
63
64 extern const struct zoran_format zoran_formats[];
65
66 static int card[BUZ_MAX] = { -1, -1, -1, -1 };
67 module_param_array(card, int, NULL, 0444);
68 MODULE_PARM_DESC(card, "The type of card");
69
70 static int encoder[BUZ_MAX] = { -1, -1, -1, -1 };
71 module_param_array(encoder, int, NULL, 0444);
72 MODULE_PARM_DESC(encoder, "i2c TV encoder");
73
74 static int decoder[BUZ_MAX] = { -1, -1, -1, -1 };
75 module_param_array(decoder, int, NULL, 0444);
76 MODULE_PARM_DESC(decoder, "i2c TV decoder");
77
78 /*
79 The video mem address of the video card.
80 The driver has a little database for some videocards
81 to determine it from there. If your video card is not in there
82 you have either to give it to the driver as a parameter
83 or set in in a VIDIOCSFBUF ioctl
84 */
85
86 static unsigned long vidmem; /* default = 0 - Video memory base address */
87 module_param(vidmem, ulong, 0444);
88 MODULE_PARM_DESC(vidmem, "Default video memory base address");
89
90 /*
91 Default input and video norm at startup of the driver.
92 */
93
94 static unsigned int default_input; /* default 0 = Composite, 1 = S-Video */
95 module_param(default_input, uint, 0444);
96 MODULE_PARM_DESC(default_input,
97 "Default input (0=Composite, 1=S-Video, 2=Internal)");
98
99 static int default_mux = 1; /* 6 Eyes input selection */
100 module_param(default_mux, int, 0644);
101 MODULE_PARM_DESC(default_mux,
102 "Default 6 Eyes mux setting (Input selection)");
103
104 static int default_norm; /* default 0 = PAL, 1 = NTSC 2 = SECAM */
105 module_param(default_norm, int, 0444);
106 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
107
108 /* /dev/videoN, -1 for autodetect */
109 static int video_nr[BUZ_MAX] = {-1, -1, -1, -1};
110 module_param_array(video_nr, int, NULL, 0444);
111 MODULE_PARM_DESC(video_nr, "video device number (-1=Auto)");
112
113 /*
114 Number and size of grab buffers for Video 4 Linux
115 The vast majority of applications should not need more than 2,
116 the very popular BTTV driver actually does ONLY have 2.
117 Time sensitive applications might need more, the maximum
118 is VIDEO_MAX_FRAME (defined in <linux/videodev.h>).
119
120 The size is set so that the maximum possible request
121 can be satisfied. Decrease it, if bigphys_area alloc'd
122 memory is low. If you don't have the bigphys_area patch,
123 set it to 128 KB. Will you allow only to grab small
124 images with V4L, but that's better than nothing.
125
126 v4l_bufsize has to be given in KB !
127
128 */
129
130 int v4l_nbufs = 2;
131 int v4l_bufsize = 128; /* Everybody should be able to work with this setting */
132 module_param(v4l_nbufs, int, 0644);
133 MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
134 module_param(v4l_bufsize, int, 0644);
135 MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
136
137 int jpg_nbufs = 32;
138 int jpg_bufsize = 512; /* max size for 100% quality full-PAL frame */
139 module_param(jpg_nbufs, int, 0644);
140 MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
141 module_param(jpg_bufsize, int, 0644);
142 MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
143
144 int pass_through = 0; /* 1=Pass through TV signal when device is not used */
145 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
146 module_param(pass_through, int, 0644);
147 MODULE_PARM_DESC(pass_through,
148 "Pass TV signal through to TV-out when idling");
149
150 int zr36067_debug = 1;
151 module_param_named(debug, zr36067_debug, int, 0644);
152 MODULE_PARM_DESC(debug, "Debug level (0-5)");
153
154 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
155 MODULE_AUTHOR("Serguei Miridonov");
156 MODULE_LICENSE("GPL");
157
158 static struct pci_device_id zr36067_pci_tbl[] = {
159 {PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057,
160 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
161 {0}
162 };
163 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
164
165 int zoran_num; /* number of Buzs in use */
166 struct zoran zoran[BUZ_MAX];
167
168 /* videocodec bus functions ZR36060 */
169 static u32
170 zr36060_read (struct videocodec *codec,
171 u16 reg)
172 {
173 struct zoran *zr = (struct zoran *) codec->master_data->data;
174 __u32 data;
175
176 if (post_office_wait(zr)
177 || post_office_write(zr, 0, 1, reg >> 8)
178 || post_office_write(zr, 0, 2, reg & 0xff)) {
179 return -1;
180 }
181
182 data = post_office_read(zr, 0, 3) & 0xff;
183 return data;
184 }
185
186 static void
187 zr36060_write (struct videocodec *codec,
188 u16 reg,
189 u32 val)
190 {
191 struct zoran *zr = (struct zoran *) codec->master_data->data;
192
193 if (post_office_wait(zr)
194 || post_office_write(zr, 0, 1, reg >> 8)
195 || post_office_write(zr, 0, 2, reg & 0xff)) {
196 return;
197 }
198
199 post_office_write(zr, 0, 3, val & 0xff);
200 }
201
202 /* videocodec bus functions ZR36050 */
203 static u32
204 zr36050_read (struct videocodec *codec,
205 u16 reg)
206 {
207 struct zoran *zr = (struct zoran *) codec->master_data->data;
208 __u32 data;
209
210 if (post_office_wait(zr)
211 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
212 return -1;
213 }
214
215 data = post_office_read(zr, 0, reg & 0x03) & 0xff; // reg. LOWBYTES + read
216 return data;
217 }
218
219 static void
220 zr36050_write (struct videocodec *codec,
221 u16 reg,
222 u32 val)
223 {
224 struct zoran *zr = (struct zoran *) codec->master_data->data;
225
226 if (post_office_wait(zr)
227 || post_office_write(zr, 1, 0, reg >> 2)) { // reg. HIGHBYTES
228 return;
229 }
230
231 post_office_write(zr, 0, reg & 0x03, val & 0xff); // reg. LOWBYTES + wr. data
232 }
233
234 /* videocodec bus functions ZR36016 */
235 static u32
236 zr36016_read (struct videocodec *codec,
237 u16 reg)
238 {
239 struct zoran *zr = (struct zoran *) codec->master_data->data;
240 __u32 data;
241
242 if (post_office_wait(zr)) {
243 return -1;
244 }
245
246 data = post_office_read(zr, 2, reg & 0x03) & 0xff; // read
247 return data;
248 }
249
250 /* hack for in zoran_device.c */
251 void
252 zr36016_write (struct videocodec *codec,
253 u16 reg,
254 u32 val)
255 {
256 struct zoran *zr = (struct zoran *) codec->master_data->data;
257
258 if (post_office_wait(zr)) {
259 return;
260 }
261
262 post_office_write(zr, 2, reg & 0x03, val & 0x0ff); // wr. data
263 }
264
265 /*
266 * Board specific information
267 */
268
269 static void
270 dc10_init (struct zoran *zr)
271 {
272 dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
273
274 /* Pixel clock selection */
275 GPIO(zr, 4, 0);
276 GPIO(zr, 5, 1);
277 /* Enable the video bus sync signals */
278 GPIO(zr, 7, 0);
279 }
280
281 static void
282 dc10plus_init (struct zoran *zr)
283 {
284 dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
285 }
286
287 static void
288 buz_init (struct zoran *zr)
289 {
290 dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
291
292 /* some stuff from Iomega */
293 pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
294 pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
295 pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
296 }
297
298 static void
299 lml33_init (struct zoran *zr)
300 {
301 dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
302
303 GPIO(zr, 2, 1); // Set Composite input/output
304 }
305
306 static void
307 avs6eyes_init (struct zoran *zr)
308 {
309 // AverMedia 6-Eyes original driver by Christer Weinigel
310
311 // Lifted straight from Christer's old driver and
312 // modified slightly by Martin Samuelsson.
313
314 int mux = default_mux; /* 1 = BT866, 7 = VID1 */
315
316 GPIO(zr, 4, 1); /* Bt866 SLEEP on */
317 udelay(2);
318
319 GPIO(zr, 0, 1); /* ZR36060 /RESET on */
320 GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
321 GPIO(zr, 2, mux & 1); /* MUX S0 */
322 GPIO(zr, 3, 0); /* /FRAME on */
323 GPIO(zr, 4, 0); /* Bt866 SLEEP off */
324 GPIO(zr, 5, mux & 2); /* MUX S1 */
325 GPIO(zr, 6, 0); /* ? */
326 GPIO(zr, 7, mux & 4); /* MUX S2 */
327
328 }
329
330 static char *
331 i2cid_to_modulename (u16 i2c_id)
332 {
333 char *name = NULL;
334
335 switch (i2c_id) {
336 case I2C_DRIVERID_SAA7110:
337 name = "saa7110";
338 break;
339 case I2C_DRIVERID_SAA7111A:
340 name = "saa7111";
341 break;
342 case I2C_DRIVERID_SAA7114:
343 name = "saa7114";
344 break;
345 case I2C_DRIVERID_SAA7185B:
346 name = "saa7185";
347 break;
348 case I2C_DRIVERID_ADV7170:
349 name = "adv7170";
350 break;
351 case I2C_DRIVERID_ADV7175:
352 name = "adv7175";
353 break;
354 case I2C_DRIVERID_BT819:
355 name = "bt819";
356 break;
357 case I2C_DRIVERID_BT856:
358 name = "bt856";
359 break;
360 case I2C_DRIVERID_VPX3220:
361 name = "vpx3220";
362 break;
363 /* case I2C_DRIVERID_VPX3224:
364 name = "vpx3224";
365 break;
366 case I2C_DRIVERID_MSE3000:
367 name = "mse3000";
368 break;*/
369 default:
370 break;
371 }
372
373 return name;
374 }
375
376 static char *
377 codecid_to_modulename (u16 codecid)
378 {
379 char *name = NULL;
380
381 switch (codecid) {
382 case CODEC_TYPE_ZR36060:
383 name = "zr36060";
384 break;
385 case CODEC_TYPE_ZR36050:
386 name = "zr36050";
387 break;
388 case CODEC_TYPE_ZR36016:
389 name = "zr36016";
390 break;
391 default:
392 break;
393 }
394
395 return name;
396 }
397
398 // struct tvnorm {
399 // u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
400 // };
401
402 static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
403 static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
404 static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
405 static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
406
407 static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
408 static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
409
410 /* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
411 static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
412 static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
413
414 /* FIXME: I cannot swap U and V in saa7114, so i do one
415 * pixel left shift in zoran (75 -> 74)
416 * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
417 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
418 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
419
420 /* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
421 * copy Maxim's left shift hack for the 6 Eyes.
422 *
423 * Christer's driver used the unshifted norms, though...
424 * /Sam */
425 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
426 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
427
428 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
429 {
430 .type = DC10_old,
431 .name = "DC10(old)",
432 .i2c_decoder = I2C_DRIVERID_VPX3220,
433 /*.i2c_encoder = I2C_DRIVERID_MSE3000,*/
434 .video_codec = CODEC_TYPE_ZR36050,
435 .video_vfe = CODEC_TYPE_ZR36016,
436
437 .inputs = 3,
438 .input = {
439 { 1, "Composite" },
440 { 2, "S-Video" },
441 { 0, "Internal/comp" }
442 },
443 .norms = 3,
444 .tvn = {
445 &f50sqpixel_dc10,
446 &f60sqpixel_dc10,
447 &f50sqpixel_dc10
448 },
449 .jpeg_int = 0,
450 .vsync_int = ZR36057_ISR_GIRQ1,
451 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
452 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
453 .gpcs = { -1, 0 },
454 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
455 .gws_not_connected = 0,
456 .input_mux = 0,
457 .init = &dc10_init,
458 }, {
459 .type = DC10_new,
460 .name = "DC10(new)",
461 .i2c_decoder = I2C_DRIVERID_SAA7110,
462 .i2c_encoder = I2C_DRIVERID_ADV7175,
463 .video_codec = CODEC_TYPE_ZR36060,
464
465 .inputs = 3,
466 .input = {
467 { 0, "Composite" },
468 { 7, "S-Video" },
469 { 5, "Internal/comp" }
470 },
471 .norms = 3,
472 .tvn = {
473 &f50sqpixel,
474 &f60sqpixel,
475 &f50sqpixel},
476 .jpeg_int = ZR36057_ISR_GIRQ0,
477 .vsync_int = ZR36057_ISR_GIRQ1,
478 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
479 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
480 .gpcs = { -1, 1},
481 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
482 .gws_not_connected = 0,
483 .input_mux = 0,
484 .init = &dc10plus_init,
485 }, {
486 .type = DC10plus,
487 .name = "DC10plus",
488 .vendor_id = PCI_VENDOR_ID_MIRO,
489 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
490 .i2c_decoder = I2C_DRIVERID_SAA7110,
491 .i2c_encoder = I2C_DRIVERID_ADV7175,
492 .video_codec = CODEC_TYPE_ZR36060,
493
494 .inputs = 3,
495 .input = {
496 { 0, "Composite" },
497 { 7, "S-Video" },
498 { 5, "Internal/comp" }
499 },
500 .norms = 3,
501 .tvn = {
502 &f50sqpixel,
503 &f60sqpixel,
504 &f50sqpixel
505 },
506 .jpeg_int = ZR36057_ISR_GIRQ0,
507 .vsync_int = ZR36057_ISR_GIRQ1,
508 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
509 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
510 .gpcs = { -1, 1 },
511 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
512 .gws_not_connected = 0,
513 .input_mux = 0,
514 .init = &dc10plus_init,
515 }, {
516 .type = DC30,
517 .name = "DC30",
518 .i2c_decoder = I2C_DRIVERID_VPX3220,
519 .i2c_encoder = I2C_DRIVERID_ADV7175,
520 .video_codec = CODEC_TYPE_ZR36050,
521 .video_vfe = CODEC_TYPE_ZR36016,
522
523 .inputs = 3,
524 .input = {
525 { 1, "Composite" },
526 { 2, "S-Video" },
527 { 0, "Internal/comp" }
528 },
529 .norms = 3,
530 .tvn = {
531 &f50sqpixel_dc10,
532 &f60sqpixel_dc10,
533 &f50sqpixel_dc10
534 },
535 .jpeg_int = 0,
536 .vsync_int = ZR36057_ISR_GIRQ1,
537 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
538 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
539 .gpcs = { -1, 0 },
540 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
541 .gws_not_connected = 0,
542 .input_mux = 0,
543 .init = &dc10_init,
544 }, {
545 .type = DC30plus,
546 .name = "DC30plus",
547 .vendor_id = PCI_VENDOR_ID_MIRO,
548 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
549 .i2c_decoder = I2C_DRIVERID_VPX3220,
550 .i2c_encoder = I2C_DRIVERID_ADV7175,
551 .video_codec = CODEC_TYPE_ZR36050,
552 .video_vfe = CODEC_TYPE_ZR36016,
553
554 .inputs = 3,
555 .input = {
556 { 1, "Composite" },
557 { 2, "S-Video" },
558 { 0, "Internal/comp" }
559 },
560 .norms = 3,
561 .tvn = {
562 &f50sqpixel_dc10,
563 &f60sqpixel_dc10,
564 &f50sqpixel_dc10
565 },
566 .jpeg_int = 0,
567 .vsync_int = ZR36057_ISR_GIRQ1,
568 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
569 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
570 .gpcs = { -1, 0 },
571 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
572 .gws_not_connected = 0,
573 .input_mux = 0,
574 .init = &dc10_init,
575 }, {
576 .type = LML33,
577 .name = "LML33",
578 .i2c_decoder = I2C_DRIVERID_BT819,
579 .i2c_encoder = I2C_DRIVERID_BT856,
580 .video_codec = CODEC_TYPE_ZR36060,
581
582 .inputs = 2,
583 .input = {
584 { 0, "Composite" },
585 { 7, "S-Video" }
586 },
587 .norms = 2,
588 .tvn = {
589 &f50ccir601_lml33,
590 &f60ccir601_lml33,
591 NULL
592 },
593 .jpeg_int = ZR36057_ISR_GIRQ1,
594 .vsync_int = ZR36057_ISR_GIRQ0,
595 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
596 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
597 .gpcs = { 3, 1 },
598 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
599 .gws_not_connected = 1,
600 .input_mux = 0,
601 .init = &lml33_init,
602 }, {
603 .type = LML33R10,
604 .name = "LML33R10",
605 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
606 .device_id = PCI_DEVICE_ID_LML_33R10,
607 .i2c_decoder = I2C_DRIVERID_SAA7114,
608 .i2c_encoder = I2C_DRIVERID_ADV7170,
609 .video_codec = CODEC_TYPE_ZR36060,
610
611 .inputs = 2,
612 .input = {
613 { 0, "Composite" },
614 { 7, "S-Video" }
615 },
616 .norms = 2,
617 .tvn = {
618 &f50ccir601_lm33r10,
619 &f60ccir601_lm33r10,
620 NULL
621 },
622 .jpeg_int = ZR36057_ISR_GIRQ1,
623 .vsync_int = ZR36057_ISR_GIRQ0,
624 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
625 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
626 .gpcs = { 3, 1 },
627 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
628 .gws_not_connected = 1,
629 .input_mux = 0,
630 .init = &lml33_init,
631 }, {
632 .type = BUZ,
633 .name = "Buz",
634 .vendor_id = PCI_VENDOR_ID_IOMEGA,
635 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
636 .i2c_decoder = I2C_DRIVERID_SAA7111A,
637 .i2c_encoder = I2C_DRIVERID_SAA7185B,
638 .video_codec = CODEC_TYPE_ZR36060,
639
640 .inputs = 2,
641 .input = {
642 { 3, "Composite" },
643 { 7, "S-Video" }
644 },
645 .norms = 3,
646 .tvn = {
647 &f50ccir601,
648 &f60ccir601,
649 &f50ccir601
650 },
651 .jpeg_int = ZR36057_ISR_GIRQ1,
652 .vsync_int = ZR36057_ISR_GIRQ0,
653 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
654 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
655 .gpcs = { 3, 1 },
656 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
657 .gws_not_connected = 1,
658 .input_mux = 0,
659 .init = &buz_init,
660 }, {
661 .type = AVS6EYES,
662 .name = "6-Eyes",
663 /* AverMedia chose not to brand the 6-Eyes. Thus it
664 can't be autodetected, and requires card=x. */
665 .vendor_id = -1,
666 .device_id = -1,
667 .i2c_decoder = I2C_DRIVERID_KS0127,
668 .i2c_encoder = I2C_DRIVERID_BT866,
669 .video_codec = CODEC_TYPE_ZR36060,
670
671 .inputs = 10,
672 .input = {
673 { 0, "Composite 1" },
674 { 1, "Composite 2" },
675 { 2, "Composite 3" },
676 { 4, "Composite 4" },
677 { 5, "Composite 5" },
678 { 6, "Composite 6" },
679 { 8, "S-Video 1" },
680 { 9, "S-Video 2" },
681 {10, "S-Video 3" },
682 {15, "YCbCr" }
683 },
684 .norms = 2,
685 .tvn = {
686 &f50ccir601_avs6eyes,
687 &f60ccir601_avs6eyes,
688 NULL
689 },
690 .jpeg_int = ZR36057_ISR_GIRQ1,
691 .vsync_int = ZR36057_ISR_GIRQ0,
692 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
693 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
694 .gpcs = { 3, 1 }, // Validity unknown /Sam
695 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam
696 .gws_not_connected = 1,
697 .input_mux = 1,
698 .init = &avs6eyes_init,
699 }
700
701 };
702
703 /*
704 * I2C functions
705 */
706 /* software I2C functions */
707 static int
708 zoran_i2c_getsda (void *data)
709 {
710 struct zoran *zr = (struct zoran *) data;
711
712 return (btread(ZR36057_I2CBR) >> 1) & 1;
713 }
714
715 static int
716 zoran_i2c_getscl (void *data)
717 {
718 struct zoran *zr = (struct zoran *) data;
719
720 return btread(ZR36057_I2CBR) & 1;
721 }
722
723 static void
724 zoran_i2c_setsda (void *data,
725 int state)
726 {
727 struct zoran *zr = (struct zoran *) data;
728
729 if (state)
730 zr->i2cbr |= 2;
731 else
732 zr->i2cbr &= ~2;
733 btwrite(zr->i2cbr, ZR36057_I2CBR);
734 }
735
736 static void
737 zoran_i2c_setscl (void *data,
738 int state)
739 {
740 struct zoran *zr = (struct zoran *) data;
741
742 if (state)
743 zr->i2cbr |= 1;
744 else
745 zr->i2cbr &= ~1;
746 btwrite(zr->i2cbr, ZR36057_I2CBR);
747 }
748
749 static int
750 zoran_i2c_client_register (struct i2c_client *client)
751 {
752 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
753 int res = 0;
754
755 dprintk(2,
756 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
757 ZR_DEVNAME(zr), client->driver->id);
758
759 mutex_lock(&zr->resource_lock);
760
761 if (zr->user > 0) {
762 /* we're already busy, so we keep a reference to
763 * them... Could do a lot of stuff here, but this
764 * is easiest. (Did I ever mention I'm a lazy ass?)
765 */
766 res = -EBUSY;
767 goto clientreg_unlock_and_return;
768 }
769
770 if (client->driver->id == zr->card.i2c_decoder)
771 zr->decoder = client;
772 else if (client->driver->id == zr->card.i2c_encoder)
773 zr->encoder = client;
774 else {
775 res = -ENODEV;
776 goto clientreg_unlock_and_return;
777 }
778
779 clientreg_unlock_and_return:
780 mutex_unlock(&zr->resource_lock);
781
782 return res;
783 }
784
785 static int
786 zoran_i2c_client_unregister (struct i2c_client *client)
787 {
788 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
789 int res = 0;
790
791 dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
792
793 mutex_lock(&zr->resource_lock);
794
795 if (zr->user > 0) {
796 res = -EBUSY;
797 goto clientunreg_unlock_and_return;
798 }
799
800 /* try to locate it */
801 if (client == zr->encoder) {
802 zr->encoder = NULL;
803 } else if (client == zr->decoder) {
804 zr->decoder = NULL;
805 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
806 }
807 clientunreg_unlock_and_return:
808 mutex_unlock(&zr->resource_lock);
809 return res;
810 }
811
812 static struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
813 .setsda = zoran_i2c_setsda,
814 .setscl = zoran_i2c_setscl,
815 .getsda = zoran_i2c_getsda,
816 .getscl = zoran_i2c_getscl,
817 .udelay = 10,
818 .timeout = 100,
819 };
820
821 static struct i2c_adapter zoran_i2c_adapter_template = {
822 .name = "zr36057",
823 .id = I2C_HW_B_ZR36067,
824 .algo = NULL,
825 .client_register = zoran_i2c_client_register,
826 .client_unregister = zoran_i2c_client_unregister,
827 };
828
829 static int
830 zoran_register_i2c (struct zoran *zr)
831 {
832 memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
833 sizeof(struct i2c_algo_bit_data));
834 zr->i2c_algo.data = zr;
835 memcpy(&zr->i2c_adapter, &zoran_i2c_adapter_template,
836 sizeof(struct i2c_adapter));
837 strncpy(I2C_NAME(&zr->i2c_adapter), ZR_DEVNAME(zr),
838 sizeof(I2C_NAME(&zr->i2c_adapter)) - 1);
839 i2c_set_adapdata(&zr->i2c_adapter, zr);
840 zr->i2c_adapter.algo_data = &zr->i2c_algo;
841 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
842 return i2c_bit_add_bus(&zr->i2c_adapter);
843 }
844
845 static void
846 zoran_unregister_i2c (struct zoran *zr)
847 {
848 i2c_del_adapter(&zr->i2c_adapter);
849 }
850
851 /* Check a zoran_params struct for correctness, insert default params */
852
853 int
854 zoran_check_jpg_settings (struct zoran *zr,
855 struct zoran_jpg_settings *settings)
856 {
857 int err = 0, err0 = 0;
858
859 dprintk(4,
860 KERN_DEBUG
861 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
862 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
863 settings->VerDcm, settings->TmpDcm);
864 dprintk(4,
865 KERN_DEBUG
866 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
867 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
868 settings->img_width, settings->img_height);
869 /* Check decimation, set default values for decimation = 1, 2, 4 */
870 switch (settings->decimation) {
871 case 1:
872
873 settings->HorDcm = 1;
874 settings->VerDcm = 1;
875 settings->TmpDcm = 1;
876 settings->field_per_buff = 2;
877 settings->img_x = 0;
878 settings->img_y = 0;
879 settings->img_width = BUZ_MAX_WIDTH;
880 settings->img_height = BUZ_MAX_HEIGHT / 2;
881 break;
882 case 2:
883
884 settings->HorDcm = 2;
885 settings->VerDcm = 1;
886 settings->TmpDcm = 2;
887 settings->field_per_buff = 1;
888 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
889 settings->img_y = 0;
890 settings->img_width =
891 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
892 settings->img_height = BUZ_MAX_HEIGHT / 2;
893 break;
894 case 4:
895
896 if (zr->card.type == DC10_new) {
897 dprintk(1,
898 KERN_DEBUG
899 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
900 ZR_DEVNAME(zr));
901 err0++;
902 break;
903 }
904
905 settings->HorDcm = 4;
906 settings->VerDcm = 2;
907 settings->TmpDcm = 2;
908 settings->field_per_buff = 1;
909 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
910 settings->img_y = 0;
911 settings->img_width =
912 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
913 settings->img_height = BUZ_MAX_HEIGHT / 2;
914 break;
915 case 0:
916
917 /* We have to check the data the user has set */
918
919 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
920 (zr->card.type == DC10_new || settings->HorDcm != 4))
921 err0++;
922 if (settings->VerDcm != 1 && settings->VerDcm != 2)
923 err0++;
924 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
925 err0++;
926 if (settings->field_per_buff != 1 &&
927 settings->field_per_buff != 2)
928 err0++;
929 if (settings->img_x < 0)
930 err0++;
931 if (settings->img_y < 0)
932 err0++;
933 if (settings->img_width < 0)
934 err0++;
935 if (settings->img_height < 0)
936 err0++;
937 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
938 err0++;
939 if (settings->img_y + settings->img_height >
940 BUZ_MAX_HEIGHT / 2)
941 err0++;
942 if (settings->HorDcm && settings->VerDcm) {
943 if (settings->img_width %
944 (16 * settings->HorDcm) != 0)
945 err0++;
946 if (settings->img_height %
947 (8 * settings->VerDcm) != 0)
948 err0++;
949 }
950
951 if (err0) {
952 dprintk(1,
953 KERN_ERR
954 "%s: check_jpg_settings() - error in params for decimation = 0\n",
955 ZR_DEVNAME(zr));
956 err++;
957 }
958 break;
959 default:
960 dprintk(1,
961 KERN_ERR
962 "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
963 ZR_DEVNAME(zr), settings->decimation);
964 err++;
965 break;
966 }
967
968 if (settings->jpg_comp.quality > 100)
969 settings->jpg_comp.quality = 100;
970 if (settings->jpg_comp.quality < 5)
971 settings->jpg_comp.quality = 5;
972 if (settings->jpg_comp.APPn < 0)
973 settings->jpg_comp.APPn = 0;
974 if (settings->jpg_comp.APPn > 15)
975 settings->jpg_comp.APPn = 15;
976 if (settings->jpg_comp.APP_len < 0)
977 settings->jpg_comp.APP_len = 0;
978 if (settings->jpg_comp.APP_len > 60)
979 settings->jpg_comp.APP_len = 60;
980 if (settings->jpg_comp.COM_len < 0)
981 settings->jpg_comp.COM_len = 0;
982 if (settings->jpg_comp.COM_len > 60)
983 settings->jpg_comp.COM_len = 60;
984 if (err)
985 return -EINVAL;
986 return 0;
987 }
988
989 void
990 zoran_open_init_params (struct zoran *zr)
991 {
992 int i;
993
994 /* User must explicitly set a window */
995 zr->overlay_settings.is_set = 0;
996 zr->overlay_mask = NULL;
997 zr->overlay_active = ZORAN_FREE;
998
999 zr->v4l_memgrab_active = 0;
1000 zr->v4l_overlay_active = 0;
1001 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
1002 zr->v4l_grab_seq = 0;
1003 zr->v4l_settings.width = 192;
1004 zr->v4l_settings.height = 144;
1005 zr->v4l_settings.format = &zoran_formats[4]; /* YUY2 - YUV-4:2:2 packed */
1006 zr->v4l_settings.bytesperline =
1007 zr->v4l_settings.width *
1008 ((zr->v4l_settings.format->depth + 7) / 8);
1009
1010 /* DMA ring stuff for V4L */
1011 zr->v4l_pend_tail = 0;
1012 zr->v4l_pend_head = 0;
1013 zr->v4l_sync_tail = 0;
1014 zr->v4l_buffers.active = ZORAN_FREE;
1015 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1016 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1017 }
1018 zr->v4l_buffers.allocated = 0;
1019
1020 for (i = 0; i < BUZ_MAX_FRAME; i++) {
1021 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1022 }
1023 zr->jpg_buffers.active = ZORAN_FREE;
1024 zr->jpg_buffers.allocated = 0;
1025 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1026 zr->jpg_settings.decimation = 1;
1027 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1028 if (zr->card.type != BUZ)
1029 zr->jpg_settings.odd_even = 1;
1030 else
1031 zr->jpg_settings.odd_even = 0;
1032 zr->jpg_settings.jpg_comp.APPn = 0;
1033 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
1034 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1035 sizeof(zr->jpg_settings.jpg_comp.APP_data));
1036 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
1037 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1038 sizeof(zr->jpg_settings.jpg_comp.COM_data));
1039 zr->jpg_settings.jpg_comp.jpeg_markers =
1040 JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1041 i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1042 if (i)
1043 dprintk(1,
1044 KERN_ERR
1045 "%s: zoran_open_init_params() internal error\n",
1046 ZR_DEVNAME(zr));
1047
1048 clear_interrupt_counters(zr);
1049 zr->testing = 0;
1050 }
1051
1052 static void __devinit
1053 test_interrupts (struct zoran *zr)
1054 {
1055 DEFINE_WAIT(wait);
1056 int timeout, icr;
1057
1058 clear_interrupt_counters(zr);
1059
1060 zr->testing = 1;
1061 icr = btread(ZR36057_ICR);
1062 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1063 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1064 timeout = schedule_timeout(HZ);
1065 finish_wait(&zr->test_q, &wait);
1066 btwrite(0, ZR36057_ICR);
1067 btwrite(0x78000000, ZR36057_ISR);
1068 zr->testing = 0;
1069 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1070 if (timeout) {
1071 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1072 }
1073 if (zr36067_debug > 1)
1074 print_interrupts(zr);
1075 btwrite(icr, ZR36057_ICR);
1076 }
1077
1078 static int __devinit
1079 zr36057_init (struct zoran *zr)
1080 {
1081 int j, err;
1082 int two = 2;
1083 int zero = 0;
1084
1085 dprintk(1,
1086 KERN_INFO
1087 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1088 ZR_DEVNAME(zr), zr->id, zr);
1089
1090 /* default setup of all parameters which will persist between opens */
1091 zr->user = 0;
1092
1093 init_waitqueue_head(&zr->v4l_capq);
1094 init_waitqueue_head(&zr->jpg_capq);
1095 init_waitqueue_head(&zr->test_q);
1096 zr->jpg_buffers.allocated = 0;
1097 zr->v4l_buffers.allocated = 0;
1098
1099 zr->buffer.base = (void *) vidmem;
1100 zr->buffer.width = 0;
1101 zr->buffer.height = 0;
1102 zr->buffer.depth = 0;
1103 zr->buffer.bytesperline = 0;
1104
1105 /* Avoid nonsense settings from user for default input/norm */
1106 if (default_norm < VIDEO_MODE_PAL &&
1107 default_norm > VIDEO_MODE_SECAM)
1108 default_norm = VIDEO_MODE_PAL;
1109 zr->norm = default_norm;
1110 if (!(zr->timing = zr->card.tvn[zr->norm])) {
1111 dprintk(1,
1112 KERN_WARNING
1113 "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1114 ZR_DEVNAME(zr));
1115 zr->norm = VIDEO_MODE_PAL;
1116 zr->timing = zr->card.tvn[zr->norm];
1117 }
1118
1119 if (default_input > zr->card.inputs-1) {
1120 dprintk(1,
1121 KERN_WARNING
1122 "%s: default_input value %d out of range (0-%d)\n",
1123 ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1124 default_input = 0;
1125 }
1126 zr->input = default_input;
1127
1128 /* Should the following be reset at every open ? */
1129 zr->hue = 32768;
1130 zr->contrast = 32768;
1131 zr->saturation = 32768;
1132 zr->brightness = 32768;
1133
1134 /* default setup (will be repeated at every open) */
1135 zoran_open_init_params(zr);
1136
1137 /* allocate memory *before* doing anything to the hardware
1138 * in case allocation fails */
1139 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1140 zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1141 if (!zr->stat_com || !zr->video_dev) {
1142 dprintk(1,
1143 KERN_ERR
1144 "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1145 ZR_DEVNAME(zr));
1146 err = -ENOMEM;
1147 goto exit_free;
1148 }
1149 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1150 zr->stat_com[j] = 1; /* mark as unavailable to zr36057 */
1151 }
1152
1153 /*
1154 * Now add the template and register the device unit.
1155 */
1156 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1157 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1158 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1159 if (err < 0)
1160 goto exit_unregister;
1161
1162 zoran_init_hardware(zr);
1163 if (zr36067_debug > 2)
1164 detect_guest_activity(zr);
1165 test_interrupts(zr);
1166 if (!pass_through) {
1167 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1168 encoder_command(zr, ENCODER_SET_INPUT, &two);
1169 }
1170
1171 zr->zoran_proc = NULL;
1172 zr->initialized = 1;
1173 return 0;
1174
1175 exit_unregister:
1176 zoran_unregister_i2c(zr);
1177 exit_free:
1178 kfree(zr->stat_com);
1179 kfree(zr->video_dev);
1180 return err;
1181 }
1182
1183 static void
1184 zoran_release (struct zoran *zr)
1185 {
1186 if (!zr->initialized)
1187 return;
1188 /* unregister videocodec bus */
1189 if (zr->codec) {
1190 struct videocodec_master *master = zr->codec->master_data;
1191
1192 videocodec_detach(zr->codec);
1193 kfree(master);
1194 }
1195 if (zr->vfe) {
1196 struct videocodec_master *master = zr->vfe->master_data;
1197
1198 videocodec_detach(zr->vfe);
1199 kfree(master);
1200 }
1201
1202 /* unregister i2c bus */
1203 zoran_unregister_i2c(zr);
1204 /* disable PCI bus-mastering */
1205 zoran_set_pci_master(zr, 0);
1206 /* put chip into reset */
1207 btwrite(0, ZR36057_SPGPPCR);
1208 free_irq(zr->pci_dev->irq, zr);
1209 /* unmap and free memory */
1210 kfree(zr->stat_com);
1211 zoran_proc_cleanup(zr);
1212 iounmap(zr->zr36057_mem);
1213 pci_disable_device(zr->pci_dev);
1214 video_unregister_device(zr->video_dev);
1215 }
1216
1217 void
1218 zoran_vdev_release (struct video_device *vdev)
1219 {
1220 kfree(vdev);
1221 }
1222
1223 static struct videocodec_master * __devinit
1224 zoran_setup_videocodec (struct zoran *zr,
1225 int type)
1226 {
1227 struct videocodec_master *m = NULL;
1228
1229 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1230 if (!m) {
1231 dprintk(1,
1232 KERN_ERR
1233 "%s: zoran_setup_videocodec() - no memory\n",
1234 ZR_DEVNAME(zr));
1235 return m;
1236 }
1237
1238 /* magic and type are unused for master struct. Makes sense only at
1239 codec structs.
1240 In the past, .type were initialized to the old V4L1 .hardware
1241 value, as VID_HARDWARE_ZR36067
1242 */
1243 m->magic = 0L;
1244 m->type = 0;
1245
1246 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1247 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1248 m->data = zr;
1249
1250 switch (type)
1251 {
1252 case CODEC_TYPE_ZR36060:
1253 m->readreg = zr36060_read;
1254 m->writereg = zr36060_write;
1255 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1256 break;
1257 case CODEC_TYPE_ZR36050:
1258 m->readreg = zr36050_read;
1259 m->writereg = zr36050_write;
1260 m->flags |= CODEC_FLAG_JPEG;
1261 break;
1262 case CODEC_TYPE_ZR36016:
1263 m->readreg = zr36016_read;
1264 m->writereg = zr36016_write;
1265 m->flags |= CODEC_FLAG_VFE;
1266 break;
1267 }
1268
1269 return m;
1270 }
1271
1272 /*
1273 * Scan for a Buz card (actually for the PCI controller ZR36057),
1274 * request the irq and map the io memory
1275 */
1276 static int __devinit
1277 find_zr36057 (void)
1278 {
1279 unsigned char latency, need_latency;
1280 struct zoran *zr;
1281 struct pci_dev *dev = NULL;
1282 int result;
1283 struct videocodec_master *master_vfe = NULL;
1284 struct videocodec_master *master_codec = NULL;
1285 int card_num;
1286 char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1287
1288 zoran_num = 0;
1289 while (zoran_num < BUZ_MAX &&
1290 (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1291 card_num = card[zoran_num];
1292 zr = &zoran[zoran_num];
1293 memset(zr, 0, sizeof(struct zoran)); // Just in case if previous cycle failed
1294 zr->pci_dev = dev;
1295 //zr->zr36057_mem = NULL;
1296 zr->id = zoran_num;
1297 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1298 spin_lock_init(&zr->spinlock);
1299 mutex_init(&zr->resource_lock);
1300 if (pci_enable_device(dev))
1301 continue;
1302 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1303 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1304 &zr->revision);
1305 if (zr->revision < 2) {
1306 dprintk(1,
1307 KERN_INFO
1308 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1309 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1310 zr->zr36057_adr);
1311
1312 if (card_num == -1) {
1313 dprintk(1,
1314 KERN_ERR
1315 "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1316 ZR_DEVNAME(zr));
1317 continue;
1318 }
1319 } else {
1320 int i;
1321 unsigned short ss_vendor, ss_device;
1322
1323 ss_vendor = zr->pci_dev->subsystem_vendor;
1324 ss_device = zr->pci_dev->subsystem_device;
1325 dprintk(1,
1326 KERN_INFO
1327 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1328 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1329 zr->zr36057_adr);
1330 dprintk(1,
1331 KERN_INFO
1332 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1333 ZR_DEVNAME(zr), ss_vendor, ss_device);
1334 if (card_num == -1) {
1335 dprintk(3,
1336 KERN_DEBUG
1337 "%s: find_zr36057() - trying to autodetect card type\n",
1338 ZR_DEVNAME(zr));
1339 for (i=0;i<NUM_CARDS;i++) {
1340 if (ss_vendor == zoran_cards[i].vendor_id &&
1341 ss_device == zoran_cards[i].device_id) {
1342 dprintk(3,
1343 KERN_DEBUG
1344 "%s: find_zr36057() - card %s detected\n",
1345 ZR_DEVNAME(zr),
1346 zoran_cards[i].name);
1347 card_num = i;
1348 break;
1349 }
1350 }
1351 if (i == NUM_CARDS) {
1352 dprintk(1,
1353 KERN_ERR
1354 "%s: find_zr36057() - unknown card\n",
1355 ZR_DEVNAME(zr));
1356 continue;
1357 }
1358 }
1359 }
1360
1361 if (card_num < 0 || card_num >= NUM_CARDS) {
1362 dprintk(2,
1363 KERN_ERR
1364 "%s: find_zr36057() - invalid cardnum %d\n",
1365 ZR_DEVNAME(zr), card_num);
1366 continue;
1367 }
1368
1369 /* even though we make this a non pointer and thus
1370 * theoretically allow for making changes to this struct
1371 * on a per-individual card basis at runtime, this is
1372 * strongly discouraged. This structure is intended to
1373 * keep general card information, no settings or anything */
1374 zr->card = zoran_cards[card_num];
1375 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1376 "%s[%u]", zr->card.name, zr->id);
1377
1378 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1379 if (!zr->zr36057_mem) {
1380 dprintk(1,
1381 KERN_ERR
1382 "%s: find_zr36057() - ioremap failed\n",
1383 ZR_DEVNAME(zr));
1384 continue;
1385 }
1386
1387 result = request_irq(zr->pci_dev->irq,
1388 zoran_irq,
1389 IRQF_SHARED | IRQF_DISABLED,
1390 ZR_DEVNAME(zr),
1391 (void *) zr);
1392 if (result < 0) {
1393 if (result == -EINVAL) {
1394 dprintk(1,
1395 KERN_ERR
1396 "%s: find_zr36057() - bad irq number or handler\n",
1397 ZR_DEVNAME(zr));
1398 } else if (result == -EBUSY) {
1399 dprintk(1,
1400 KERN_ERR
1401 "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1402 ZR_DEVNAME(zr), zr->pci_dev->irq);
1403 } else {
1404 dprintk(1,
1405 KERN_ERR
1406 "%s: find_zr36057() - can't assign irq, error code %d\n",
1407 ZR_DEVNAME(zr), result);
1408 }
1409 goto zr_unmap;
1410 }
1411
1412 /* set PCI latency timer */
1413 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1414 &latency);
1415 need_latency = zr->revision > 1 ? 32 : 48;
1416 if (latency != need_latency) {
1417 dprintk(2,
1418 KERN_INFO
1419 "%s: Changing PCI latency from %d to %d.\n",
1420 ZR_DEVNAME(zr), latency, need_latency);
1421 pci_write_config_byte(zr->pci_dev,
1422 PCI_LATENCY_TIMER,
1423 need_latency);
1424 }
1425
1426 zr36057_restart(zr);
1427 /* i2c */
1428 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1429 ZR_DEVNAME(zr));
1430
1431 /* i2c decoder */
1432 if (decoder[zr->id] != -1) {
1433 i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1434 zr->card.i2c_decoder = decoder[zr->id];
1435 } else if (zr->card.i2c_decoder != 0) {
1436 i2c_dec_name =
1437 i2cid_to_modulename(zr->card.i2c_decoder);
1438 } else {
1439 i2c_dec_name = NULL;
1440 }
1441
1442 if (i2c_dec_name) {
1443 if ((result = request_module(i2c_dec_name)) < 0) {
1444 dprintk(1,
1445 KERN_ERR
1446 "%s: failed to load module %s: %d\n",
1447 ZR_DEVNAME(zr), i2c_dec_name, result);
1448 }
1449 }
1450
1451 /* i2c encoder */
1452 if (encoder[zr->id] != -1) {
1453 i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1454 zr->card.i2c_encoder = encoder[zr->id];
1455 } else if (zr->card.i2c_encoder != 0) {
1456 i2c_enc_name =
1457 i2cid_to_modulename(zr->card.i2c_encoder);
1458 } else {
1459 i2c_enc_name = NULL;
1460 }
1461
1462 if (i2c_enc_name) {
1463 if ((result = request_module(i2c_enc_name)) < 0) {
1464 dprintk(1,
1465 KERN_ERR
1466 "%s: failed to load module %s: %d\n",
1467 ZR_DEVNAME(zr), i2c_enc_name, result);
1468 }
1469 }
1470
1471 if (zoran_register_i2c(zr) < 0) {
1472 dprintk(1,
1473 KERN_ERR
1474 "%s: find_zr36057() - can't initialize i2c bus\n",
1475 ZR_DEVNAME(zr));
1476 goto zr_free_irq;
1477 }
1478
1479 dprintk(2,
1480 KERN_INFO "%s: Initializing videocodec bus...\n",
1481 ZR_DEVNAME(zr));
1482
1483 if (zr->card.video_codec != 0 &&
1484 (codec_name =
1485 codecid_to_modulename(zr->card.video_codec)) != NULL) {
1486 if ((result = request_module(codec_name)) < 0) {
1487 dprintk(1,
1488 KERN_ERR
1489 "%s: failed to load modules %s: %d\n",
1490 ZR_DEVNAME(zr), codec_name, result);
1491 }
1492 }
1493 if (zr->card.video_vfe != 0 &&
1494 (vfe_name =
1495 codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1496 if ((result = request_module(vfe_name)) < 0) {
1497 dprintk(1,
1498 KERN_ERR
1499 "%s: failed to load modules %s: %d\n",
1500 ZR_DEVNAME(zr), vfe_name, result);
1501 }
1502 }
1503
1504 /* reset JPEG codec */
1505 jpeg_codec_sleep(zr, 1);
1506 jpeg_codec_reset(zr);
1507 /* video bus enabled */
1508 /* display codec revision */
1509 if (zr->card.video_codec != 0) {
1510 master_codec = zoran_setup_videocodec(zr,
1511 zr->card.video_codec);
1512 if (!master_codec)
1513 goto zr_unreg_i2c;
1514 zr->codec = videocodec_attach(master_codec);
1515 if (!zr->codec) {
1516 dprintk(1,
1517 KERN_ERR
1518 "%s: find_zr36057() - no codec found\n",
1519 ZR_DEVNAME(zr));
1520 goto zr_free_codec;
1521 }
1522 if (zr->codec->type != zr->card.video_codec) {
1523 dprintk(1,
1524 KERN_ERR
1525 "%s: find_zr36057() - wrong codec\n",
1526 ZR_DEVNAME(zr));
1527 goto zr_detach_codec;
1528 }
1529 }
1530 if (zr->card.video_vfe != 0) {
1531 master_vfe = zoran_setup_videocodec(zr,
1532 zr->card.video_vfe);
1533 if (!master_vfe)
1534 goto zr_detach_codec;
1535 zr->vfe = videocodec_attach(master_vfe);
1536 if (!zr->vfe) {
1537 dprintk(1,
1538 KERN_ERR
1539 "%s: find_zr36057() - no VFE found\n",
1540 ZR_DEVNAME(zr));
1541 goto zr_free_vfe;
1542 }
1543 if (zr->vfe->type != zr->card.video_vfe) {
1544 dprintk(1,
1545 KERN_ERR
1546 "%s: find_zr36057() = wrong VFE\n",
1547 ZR_DEVNAME(zr));
1548 goto zr_detach_vfe;
1549 }
1550 }
1551 /* Success so keep the pci_dev referenced */
1552 pci_dev_get(zr->pci_dev);
1553 zoran_num++;
1554 continue;
1555
1556 // Init errors
1557 zr_detach_vfe:
1558 videocodec_detach(zr->vfe);
1559 zr_free_vfe:
1560 kfree(master_vfe);
1561 zr_detach_codec:
1562 videocodec_detach(zr->codec);
1563 zr_free_codec:
1564 kfree(master_codec);
1565 zr_unreg_i2c:
1566 zoran_unregister_i2c(zr);
1567 zr_free_irq:
1568 btwrite(0, ZR36057_SPGPPCR);
1569 free_irq(zr->pci_dev->irq, zr);
1570 zr_unmap:
1571 iounmap(zr->zr36057_mem);
1572 continue;
1573 }
1574 if (dev) /* Clean up ref count on early exit */
1575 pci_dev_put(dev);
1576
1577 if (zoran_num == 0) {
1578 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1579 }
1580 return zoran_num;
1581 }
1582
1583 static int __init
1584 init_dc10_cards (void)
1585 {
1586 int i;
1587
1588 memset(zoran, 0, sizeof(zoran));
1589 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1590 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1591
1592 /* Look for cards */
1593 if (find_zr36057() < 0) {
1594 return -EIO;
1595 }
1596 if (zoran_num == 0)
1597 return -ENODEV;
1598 dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1599 zoran_num);
1600 /* check the parameters we have been given, adjust if necessary */
1601 if (v4l_nbufs < 2)
1602 v4l_nbufs = 2;
1603 if (v4l_nbufs > VIDEO_MAX_FRAME)
1604 v4l_nbufs = VIDEO_MAX_FRAME;
1605 /* The user specfies the in KB, we want them in byte
1606 * (and page aligned) */
1607 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1608 if (v4l_bufsize < 32768)
1609 v4l_bufsize = 32768;
1610 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1611 if (v4l_bufsize > 2048 * 1024)
1612 v4l_bufsize = 2048 * 1024;
1613 if (jpg_nbufs < 4)
1614 jpg_nbufs = 4;
1615 if (jpg_nbufs > BUZ_MAX_FRAME)
1616 jpg_nbufs = BUZ_MAX_FRAME;
1617 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1618 if (jpg_bufsize < 8192)
1619 jpg_bufsize = 8192;
1620 if (jpg_bufsize > (512 * 1024))
1621 jpg_bufsize = 512 * 1024;
1622 /* Use parameter for vidmem or try to find a video card */
1623 if (vidmem) {
1624 dprintk(1,
1625 KERN_INFO
1626 "%s: Using supplied video memory base address @ 0x%lx\n",
1627 ZORAN_NAME, vidmem);
1628 }
1629
1630 /* random nonsense */
1631 dprintk(6, KERN_DEBUG "Jotti is een held!\n");
1632
1633 /* some mainboards might not do PCI-PCI data transfer well */
1634 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1635 dprintk(1,
1636 KERN_WARNING
1637 "%s: chipset does not support reliable PCI-PCI DMA\n",
1638 ZORAN_NAME);
1639 }
1640
1641 /* take care of Natoma chipset and a revision 1 zr36057 */
1642 for (i = 0; i < zoran_num; i++) {
1643 struct zoran *zr = &zoran[i];
1644
1645 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1646 zr->jpg_buffers.need_contiguous = 1;
1647 dprintk(1,
1648 KERN_INFO
1649 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1650 ZR_DEVNAME(zr));
1651 }
1652
1653 if (zr36057_init(zr) < 0) {
1654 for (i = 0; i < zoran_num; i++)
1655 zoran_release(&zoran[i]);
1656 return -EIO;
1657 }
1658 zoran_proc_init(zr);
1659 }
1660
1661 return 0;
1662 }
1663
1664 static void __exit
1665 unload_dc10_cards (void)
1666 {
1667 int i;
1668
1669 for (i = 0; i < zoran_num; i++)
1670 zoran_release(&zoran[i]);
1671 }
1672
1673 module_init(init_dc10_cards);
1674 module_exit(unload_dc10_cards);
Linux for Ginger Game Console