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