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