projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master'
[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 = (unsigned long) kmalloc(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 memset((void *) mem, 0, mem_needed);
1065 zr->stat_com = (u32 *) mem;
1066 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
1067 zr->stat_com[j] = 1; /* mark as unavailable to zr36057 */
1068 }
1069
1070 /*
1071 * Now add the template and register the device unit.
1072 */
1073 zr->video_dev = vdev;
1074 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1075 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1076 if (video_register_device(zr->video_dev, VFL_TYPE_GRABBER,
1077 video_nr) < 0) {
1078 zoran_unregister_i2c(zr);
1079 kfree((void *) zr->stat_com);
1080 kfree(vdev);
1081 return -1;
1082 }
1083
1084 zoran_init_hardware(zr);
1085 if (*zr_debug > 2)
1086 detect_guest_activity(zr);
1087 test_interrupts(zr);
1088 if (!pass_through) {
1089 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1090 encoder_command(zr, ENCODER_SET_INPUT, &two);
1091 }
1092
1093 zr->zoran_proc = NULL;
1094 zr->initialized = 1;
1095 return 0;
1096 }
1097
1098 static void
1099 zoran_release (struct zoran *zr)
1100 {
1101 if (!zr->initialized)
1102 return;
1103 /* unregister videocodec bus */
1104 if (zr->codec) {
1105 struct videocodec_master *master = zr->codec->master_data;
1106
1107 videocodec_detach(zr->codec);
1108 kfree(master);
1109 }
1110 if (zr->vfe) {
1111 struct videocodec_master *master = zr->vfe->master_data;
1112
1113 videocodec_detach(zr->vfe);
1114 kfree(master);
1115 }
1116
1117 /* unregister i2c bus */
1118 zoran_unregister_i2c(zr);
1119 /* disable PCI bus-mastering */
1120 zoran_set_pci_master(zr, 0);
1121 /* put chip into reset */
1122 btwrite(0, ZR36057_SPGPPCR);
1123 free_irq(zr->pci_dev->irq, zr);
1124 /* unmap and free memory */
1125 kfree((void *) zr->stat_com);
1126 zoran_proc_cleanup(zr);
1127 iounmap(zr->zr36057_mem);
1128 pci_disable_device(zr->pci_dev);
1129 video_unregister_device(zr->video_dev);
1130 }
1131
1132 void
1133 zoran_vdev_release (struct video_device *vdev)
1134 {
1135 kfree(vdev);
1136 }
1137
1138 static struct videocodec_master * __devinit
1139 zoran_setup_videocodec (struct zoran *zr,
1140 int type)
1141 {
1142 struct videocodec_master *m = NULL;
1143
1144 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1145 if (!m) {
1146 dprintk(1,
1147 KERN_ERR
1148 "%s: zoran_setup_videocodec() - no memory\n",
1149 ZR_DEVNAME(zr));
1150 return m;
1151 }
1152
1153 m->magic = 0L; /* magic not used */
1154 m->type = VID_HARDWARE_ZR36067;
1155 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1156 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1157 m->data = zr;
1158
1159 switch (type)
1160 {
1161 case CODEC_TYPE_ZR36060:
1162 m->readreg = zr36060_read;
1163 m->writereg = zr36060_write;
1164 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1165 break;
1166 case CODEC_TYPE_ZR36050:
1167 m->readreg = zr36050_read;
1168 m->writereg = zr36050_write;
1169 m->flags |= CODEC_FLAG_JPEG;
1170 break;
1171 case CODEC_TYPE_ZR36016:
1172 m->readreg = zr36016_read;
1173 m->writereg = zr36016_write;
1174 m->flags |= CODEC_FLAG_VFE;
1175 break;
1176 }
1177
1178 return m;
1179 }
1180
1181 /*
1182 * Scan for a Buz card (actually for the PCI contoler ZR36057),
1183 * request the irq and map the io memory
1184 */
1185 static int __devinit
1186 find_zr36057 (void)
1187 {
1188 unsigned char latency, need_latency;
1189 struct zoran *zr;
1190 struct pci_dev *dev = NULL;
1191 int result;
1192 struct videocodec_master *master_vfe = NULL;
1193 struct videocodec_master *master_codec = NULL;
1194 int card_num;
1195 char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1196
1197 zoran_num = 0;
1198 while (zoran_num < BUZ_MAX &&
1199 (dev =
1200 pci_find_device(PCI_VENDOR_ID_ZORAN,
1201 PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1202 card_num = card[zoran_num];
1203 zr = &zoran[zoran_num];
1204 memset(zr, 0, sizeof(struct zoran)); // Just in case if previous cycle failed
1205 zr->pci_dev = dev;
1206 //zr->zr36057_mem = NULL;
1207 zr->id = zoran_num;
1208 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1209 spin_lock_init(&zr->spinlock);
1210 init_MUTEX(&zr->resource_lock);
1211 if (pci_enable_device(dev))
1212 continue;
1213 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
1214 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION,
1215 &zr->revision);
1216 if (zr->revision < 2) {
1217 dprintk(1,
1218 KERN_INFO
1219 "%s: Zoran ZR36057 (rev %d) irq: %d, memory: 0x%08x.\n",
1220 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1221 zr->zr36057_adr);
1222
1223 if (card_num == -1) {
1224 dprintk(1,
1225 KERN_ERR
1226 "%s: find_zr36057() - no card specified, please use the card=X insmod option\n",
1227 ZR_DEVNAME(zr));
1228 continue;
1229 }
1230 } else {
1231 int i;
1232 unsigned short ss_vendor, ss_device;
1233
1234 ss_vendor = zr->pci_dev->subsystem_vendor;
1235 ss_device = zr->pci_dev->subsystem_device;
1236 dprintk(1,
1237 KERN_INFO
1238 "%s: Zoran ZR36067 (rev %d) irq: %d, memory: 0x%08x\n",
1239 ZR_DEVNAME(zr), zr->revision, zr->pci_dev->irq,
1240 zr->zr36057_adr);
1241 dprintk(1,
1242 KERN_INFO
1243 "%s: subsystem vendor=0x%04x id=0x%04x\n",
1244 ZR_DEVNAME(zr), ss_vendor, ss_device);
1245 if (card_num == -1) {
1246 dprintk(3,
1247 KERN_DEBUG
1248 "%s: find_zr36057() - trying to autodetect card type\n",
1249 ZR_DEVNAME(zr));
1250 for (i=0;i<NUM_CARDS;i++) {
1251 if (ss_vendor == zoran_cards[i].vendor_id &&
1252 ss_device == zoran_cards[i].device_id) {
1253 dprintk(3,
1254 KERN_DEBUG
1255 "%s: find_zr36057() - card %s detected\n",
1256 ZR_DEVNAME(zr),
1257 zoran_cards[i].name);
1258 card_num = i;
1259 break;
1260 }
1261 }
1262 if (i == NUM_CARDS) {
1263 dprintk(1,
1264 KERN_ERR
1265 "%s: find_zr36057() - unknown card\n",
1266 ZR_DEVNAME(zr));
1267 continue;
1268 }
1269 }
1270 }
1271
1272 if (card_num < 0 || card_num >= NUM_CARDS) {
1273 dprintk(2,
1274 KERN_ERR
1275 "%s: find_zr36057() - invalid cardnum %d\n",
1276 ZR_DEVNAME(zr), card_num);
1277 continue;
1278 }
1279
1280 /* even though we make this a non pointer and thus
1281 * theoretically allow for making changes to this struct
1282 * on a per-individual card basis at runtime, this is
1283 * strongly discouraged. This structure is intended to
1284 * keep general card information, no settings or anything */
1285 zr->card = zoran_cards[card_num];
1286 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1287 "%s[%u]", zr->card.name, zr->id);
1288
1289 zr->zr36057_mem = ioremap_nocache(zr->zr36057_adr, 0x1000);
1290 if (!zr->zr36057_mem) {
1291 dprintk(1,
1292 KERN_ERR
1293 "%s: find_zr36057() - ioremap failed\n",
1294 ZR_DEVNAME(zr));
1295 continue;
1296 }
1297
1298 result = request_irq(zr->pci_dev->irq,
1299 zoran_irq,
1300 SA_SHIRQ | SA_INTERRUPT,
1301 ZR_DEVNAME(zr),
1302 (void *) zr);
1303 if (result < 0) {
1304 if (result == -EINVAL) {
1305 dprintk(1,
1306 KERN_ERR
1307 "%s: find_zr36057() - bad irq number or handler\n",
1308 ZR_DEVNAME(zr));
1309 } else if (result == -EBUSY) {
1310 dprintk(1,
1311 KERN_ERR
1312 "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1313 ZR_DEVNAME(zr), zr->pci_dev->irq);
1314 } else {
1315 dprintk(1,
1316 KERN_ERR
1317 "%s: find_zr36057() - can't assign irq, error code %d\n",
1318 ZR_DEVNAME(zr), result);
1319 }
1320 goto zr_unmap;
1321 }
1322
1323 /* set PCI latency timer */
1324 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1325 &latency);
1326 need_latency = zr->revision > 1 ? 32 : 48;
1327 if (latency != need_latency) {
1328 dprintk(2,
1329 KERN_INFO
1330 "%s: Changing PCI latency from %d to %d.\n",
1331 ZR_DEVNAME(zr), latency, need_latency);
1332 pci_write_config_byte(zr->pci_dev,
1333 PCI_LATENCY_TIMER,
1334 need_latency);
1335 }
1336
1337 zr36057_restart(zr);
1338 /* i2c */
1339 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1340 ZR_DEVNAME(zr));
1341
1342 /* i2c decoder */
1343 if (decoder[zr->id] != -1) {
1344 i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
1345 zr->card.i2c_decoder = decoder[zr->id];
1346 } else if (zr->card.i2c_decoder != 0) {
1347 i2c_dec_name =
1348 i2cid_to_modulename(zr->card.i2c_decoder);
1349 } else {
1350 i2c_dec_name = NULL;
1351 }
1352
1353 if (i2c_dec_name) {
1354 if ((result = request_module(i2c_dec_name)) < 0) {
1355 dprintk(1,
1356 KERN_ERR
1357 "%s: failed to load module %s: %d\n",
1358 ZR_DEVNAME(zr), i2c_dec_name, result);
1359 }
1360 }
1361
1362 /* i2c encoder */
1363 if (encoder[zr->id] != -1) {
1364 i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
1365 zr->card.i2c_encoder = encoder[zr->id];
1366 } else if (zr->card.i2c_encoder != 0) {
1367 i2c_enc_name =
1368 i2cid_to_modulename(zr->card.i2c_encoder);
1369 } else {
1370 i2c_enc_name = NULL;
1371 }
1372
1373 if (i2c_enc_name) {
1374 if ((result = request_module(i2c_enc_name)) < 0) {
1375 dprintk(1,
1376 KERN_ERR
1377 "%s: failed to load module %s: %d\n",
1378 ZR_DEVNAME(zr), i2c_enc_name, result);
1379 }
1380 }
1381
1382 if (zoran_register_i2c(zr) < 0) {
1383 dprintk(1,
1384 KERN_ERR
1385 "%s: find_zr36057() - can't initialize i2c bus\n",
1386 ZR_DEVNAME(zr));
1387 goto zr_free_irq;
1388 }
1389
1390 dprintk(2,
1391 KERN_INFO "%s: Initializing videocodec bus...\n",
1392 ZR_DEVNAME(zr));
1393
1394 if (zr->card.video_codec != 0 &&
1395 (codec_name =
1396 codecid_to_modulename(zr->card.video_codec)) != NULL) {
1397 if ((result = request_module(codec_name)) < 0) {
1398 dprintk(1,
1399 KERN_ERR
1400 "%s: failed to load modules %s: %d\n",
1401 ZR_DEVNAME(zr), codec_name, result);
1402 }
1403 }
1404 if (zr->card.video_vfe != 0 &&
1405 (vfe_name =
1406 codecid_to_modulename(zr->card.video_vfe)) != NULL) {
1407 if ((result = request_module(vfe_name)) < 0) {
1408 dprintk(1,
1409 KERN_ERR
1410 "%s: failed to load modules %s: %d\n",
1411 ZR_DEVNAME(zr), vfe_name, result);
1412 }
1413 }
1414
1415 /* reset JPEG codec */
1416 jpeg_codec_sleep(zr, 1);
1417 jpeg_codec_reset(zr);
1418 /* video bus enabled */
1419 /* display codec revision */
1420 if (zr->card.video_codec != 0) {
1421 master_codec = zoran_setup_videocodec(zr,
1422 zr->card.video_codec);
1423 if (!master_codec)
1424 goto zr_unreg_i2c;
1425 zr->codec = videocodec_attach(master_codec);
1426 if (!zr->codec) {
1427 dprintk(1,
1428 KERN_ERR
1429 "%s: find_zr36057() - no codec found\n",
1430 ZR_DEVNAME(zr));
1431 goto zr_free_codec;
1432 }
1433 if (zr->codec->type != zr->card.video_codec) {
1434 dprintk(1,
1435 KERN_ERR
1436 "%s: find_zr36057() - wrong codec\n",
1437 ZR_DEVNAME(zr));
1438 goto zr_detach_codec;
1439 }
1440 }
1441 if (zr->card.video_vfe != 0) {
1442 master_vfe = zoran_setup_videocodec(zr,
1443 zr->card.video_vfe);
1444 if (!master_vfe)
1445 goto zr_detach_codec;
1446 zr->vfe = videocodec_attach(master_vfe);
1447 if (!zr->vfe) {
1448 dprintk(1,
1449 KERN_ERR
1450 "%s: find_zr36057() - no VFE found\n",
1451 ZR_DEVNAME(zr));
1452 goto zr_free_vfe;
1453 }
1454 if (zr->vfe->type != zr->card.video_vfe) {
1455 dprintk(1,
1456 KERN_ERR
1457 "%s: find_zr36057() = wrong VFE\n",
1458 ZR_DEVNAME(zr));
1459 goto zr_detach_vfe;
1460 }
1461 }
1462
1463 zoran_num++;
1464 continue;
1465
1466 // Init errors
1467 zr_detach_vfe:
1468 videocodec_detach(zr->vfe);
1469 zr_free_vfe:
1470 kfree(master_vfe);
1471 zr_detach_codec:
1472 videocodec_detach(zr->codec);
1473 zr_free_codec:
1474 kfree(master_codec);
1475 zr_unreg_i2c:
1476 zoran_unregister_i2c(zr);
1477 zr_free_irq:
1478 btwrite(0, ZR36057_SPGPPCR);
1479 free_irq(zr->pci_dev->irq, zr);
1480 zr_unmap:
1481 iounmap(zr->zr36057_mem);
1482 continue;
1483 }
1484 if (zoran_num == 0) {
1485 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1486 }
1487 return zoran_num;
1488 }
1489
1490 static int __init
1491 init_dc10_cards (void)
1492 {
1493 int i;
1494
1495 memset(zoran, 0, sizeof(zoran));
1496 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1497 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1498
1499 /* Look for cards */
1500 if (find_zr36057() < 0) {
1501 return -EIO;
1502 }
1503 if (zoran_num == 0)
1504 return -ENODEV;
1505 dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1506 zoran_num);
1507 /* check the parameters we have been given, adjust if necessary */
1508 if (v4l_nbufs < 2)
1509 v4l_nbufs = 2;
1510 if (v4l_nbufs > VIDEO_MAX_FRAME)
1511 v4l_nbufs = VIDEO_MAX_FRAME;
1512 /* The user specfies the in KB, we want them in byte
1513 * (and page aligned) */
1514 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1515 if (v4l_bufsize < 32768)
1516 v4l_bufsize = 32768;
1517 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1518 if (v4l_bufsize > 2048 * 1024)
1519 v4l_bufsize = 2048 * 1024;
1520 if (jpg_nbufs < 4)
1521 jpg_nbufs = 4;
1522 if (jpg_nbufs > BUZ_MAX_FRAME)
1523 jpg_nbufs = BUZ_MAX_FRAME;
1524 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1525 if (jpg_bufsize < 8192)
1526 jpg_bufsize = 8192;
1527 if (jpg_bufsize > (512 * 1024))
1528 jpg_bufsize = 512 * 1024;
1529 /* Use parameter for vidmem or try to find a video card */
1530 if (vidmem) {
1531 dprintk(1,
1532 KERN_INFO
1533 "%s: Using supplied video memory base address @ 0x%lx\n",
1534 ZORAN_NAME, vidmem);
1535 }
1536
1537 /* random nonsense */
1538 dprintk(5, KERN_DEBUG "Jotti is een held!\n");
1539
1540 /* some mainboards might not do PCI-PCI data transfer well */
1541 if (pci_pci_problems & PCIPCI_FAIL) {
1542 dprintk(1,
1543 KERN_WARNING
1544 "%s: chipset may not support reliable PCI-PCI DMA\n",
1545 ZORAN_NAME);
1546 }
1547
1548 /* take care of Natoma chipset and a revision 1 zr36057 */
1549 for (i = 0; i < zoran_num; i++) {
1550 struct zoran *zr = &zoran[i];
1551
1552 if (pci_pci_problems & PCIPCI_NATOMA && zr->revision <= 1) {
1553 zr->jpg_buffers.need_contiguous = 1;
1554 dprintk(1,
1555 KERN_INFO
1556 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1557 ZR_DEVNAME(zr));
1558 }
1559
1560 if (zr36057_init(zr) < 0) {
1561 for (i = 0; i < zoran_num; i++)
1562 zoran_release(&zoran[i]);
1563 return -EIO;
1564 }
1565 zoran_proc_init(zr);
1566 }
1567
1568 return 0;
1569 }
1570
1571 static void __exit
1572 unload_dc10_cards (void)
1573 {
1574 int i;
1575
1576 for (i = 0; i < zoran_num; i++)
1577 zoran_release(&zoran[i]);
1578 }
1579
1580 module_init(init_dc10_cards);
1581 module_exit(unload_dc10_cards);
Linux kernel - Deliverables
This page took 0.079112 seconds and 6 git commands to generate.