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