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