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