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