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