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