projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'next' into for-linus
[linux-2.6-block.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 163int zoran_num; /* number of Buzs in use */
85b9b8a4 164struct zoran *zoran[BUZ_MAX];
1da177e4
LT		 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;
ed1aedb1
MS		 358 case I2C_DRIVERID_BT866:
359 name = "bt866";
360 break;
1da177e4
LT		 361 case I2C_DRIVERID_VPX3220:
362 name = "vpx3220";
363 break;
ed1aedb1
MS		 364 case I2C_DRIVERID_KS0127:
365 name = "ks0127";
366 break;
1da177e4
LT		 367 }
368
369 return name;
370}
371
372static char *
373codecid_to_modulename (u16 codecid)
374{
375 char *name = NULL;
376
377 switch (codecid) {
378 case CODEC_TYPE_ZR36060:
379 name = "zr36060";
380 break;
381 case CODEC_TYPE_ZR36050:
382 name = "zr36050";
383 break;
384 case CODEC_TYPE_ZR36016:
385 name = "zr36016";
386 break;
1da177e4
LT		 387 }
388
389 return name;
390}
391
392// struct tvnorm {
393// u16 Wt, Wa, HStart, HSyncStart, Ht, Ha, VStart;
394// };
395
396static struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
397static struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
398static struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
399static struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
400
401static struct tvnorm f50ccir601_lml33 = { 864, 720, 75+34, 804, 625, 576, 18 };
402static struct tvnorm f60ccir601_lml33 = { 858, 720, 57+34, 788, 525, 480, 16 };
403
404/* The DC10 (57/16/50) uses VActive as HSync, so HStart must be 0 */
405static struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
406static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
407
408/* FIXME: I cannot swap U and V in saa7114, so i do one
409 * pixel left shift in zoran (75 -> 74)
410 * (Maxim Yevtyushkin <max@linuxmedialabs.com>) */
411static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
412static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
413
fbe60daa
MS		 414/* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
415 * copy Maxim's left shift hack for the 6 Eyes.
416 *
417 * Christer's driver used the unshifted norms, though...
418 * /Sam */
419static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
420static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
421
1da177e4
LT		 422static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
423 {
424 .type = DC10_old,
425 .name = "DC10(old)",
426 .i2c_decoder = I2C_DRIVERID_VPX3220,
1da177e4
LT		 427 .video_codec = CODEC_TYPE_ZR36050,
428 .video_vfe = CODEC_TYPE_ZR36016,
429
430 .inputs = 3,
431 .input = {
432 { 1, "Composite" },
433 { 2, "S-Video" },
434 { 0, "Internal/comp" }
435 },
436 .norms = 3,
437 .tvn = {
438 &f50sqpixel_dc10,
439 &f60sqpixel_dc10,
440 &f50sqpixel_dc10
441 },
442 .jpeg_int = 0,
443 .vsync_int = ZR36057_ISR_GIRQ1,
444 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
445 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
446 .gpcs = { -1, 0 },
447 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
448 .gws_not_connected = 0,
fbe60daa 449 .input_mux = 0,
1da177e4
LT		 450 .init = &dc10_init,
451 }, {
452 .type = DC10_new,
453 .name = "DC10(new)",
454 .i2c_decoder = I2C_DRIVERID_SAA7110,
455 .i2c_encoder = I2C_DRIVERID_ADV7175,
456 .video_codec = CODEC_TYPE_ZR36060,
457
458 .inputs = 3,
459 .input = {
460 { 0, "Composite" },
461 { 7, "S-Video" },
462 { 5, "Internal/comp" }
463 },
464 .norms = 3,
465 .tvn = {
466 &f50sqpixel,
467 &f60sqpixel,
468 &f50sqpixel},
469 .jpeg_int = ZR36057_ISR_GIRQ0,
470 .vsync_int = ZR36057_ISR_GIRQ1,
471 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
472 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
473 .gpcs = { -1, 1},
474 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
475 .gws_not_connected = 0,
fbe60daa 476 .input_mux = 0,
1da177e4
LT		 477 .init = &dc10plus_init,
478 }, {
479 .type = DC10plus,
480 .name = "DC10plus",
481 .vendor_id = PCI_VENDOR_ID_MIRO,
482 .device_id = PCI_DEVICE_ID_MIRO_DC10PLUS,
483 .i2c_decoder = I2C_DRIVERID_SAA7110,
484 .i2c_encoder = I2C_DRIVERID_ADV7175,
485 .video_codec = CODEC_TYPE_ZR36060,
486
487 .inputs = 3,
488 .input = {
489 { 0, "Composite" },
490 { 7, "S-Video" },
491 { 5, "Internal/comp" }
492 },
493 .norms = 3,
494 .tvn = {
495 &f50sqpixel,
496 &f60sqpixel,
497 &f50sqpixel
498 },
499 .jpeg_int = ZR36057_ISR_GIRQ0,
500 .vsync_int = ZR36057_ISR_GIRQ1,
501 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
502 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
503 .gpcs = { -1, 1 },
504 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
505 .gws_not_connected = 0,
fbe60daa 506 .input_mux = 0,
1da177e4
LT		 507 .init = &dc10plus_init,
508 }, {
509 .type = DC30,
510 .name = "DC30",
511 .i2c_decoder = I2C_DRIVERID_VPX3220,
512 .i2c_encoder = I2C_DRIVERID_ADV7175,
513 .video_codec = CODEC_TYPE_ZR36050,
514 .video_vfe = CODEC_TYPE_ZR36016,
515
516 .inputs = 3,
517 .input = {
518 { 1, "Composite" },
519 { 2, "S-Video" },
520 { 0, "Internal/comp" }
521 },
522 .norms = 3,
523 .tvn = {
524 &f50sqpixel_dc10,
525 &f60sqpixel_dc10,
526 &f50sqpixel_dc10
527 },
528 .jpeg_int = 0,
529 .vsync_int = ZR36057_ISR_GIRQ1,
530 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
531 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
532 .gpcs = { -1, 0 },
533 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
534 .gws_not_connected = 0,
fbe60daa 535 .input_mux = 0,
1da177e4
LT		 536 .init = &dc10_init,
537 }, {
538 .type = DC30plus,
539 .name = "DC30plus",
540 .vendor_id = PCI_VENDOR_ID_MIRO,
541 .device_id = PCI_DEVICE_ID_MIRO_DC30PLUS,
542 .i2c_decoder = I2C_DRIVERID_VPX3220,
543 .i2c_encoder = I2C_DRIVERID_ADV7175,
544 .video_codec = CODEC_TYPE_ZR36050,
545 .video_vfe = CODEC_TYPE_ZR36016,
546
547 .inputs = 3,
548 .input = {
549 { 1, "Composite" },
550 { 2, "S-Video" },
551 { 0, "Internal/comp" }
552 },
553 .norms = 3,
554 .tvn = {
555 &f50sqpixel_dc10,
556 &f60sqpixel_dc10,
557 &f50sqpixel_dc10
558 },
559 .jpeg_int = 0,
560 .vsync_int = ZR36057_ISR_GIRQ1,
561 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
562 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
563 .gpcs = { -1, 0 },
564 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
565 .gws_not_connected = 0,
fbe60daa 566 .input_mux = 0,
1da177e4
LT		 567 .init = &dc10_init,
568 }, {
569 .type = LML33,
570 .name = "LML33",
571 .i2c_decoder = I2C_DRIVERID_BT819,
572 .i2c_encoder = I2C_DRIVERID_BT856,
573 .video_codec = CODEC_TYPE_ZR36060,
574
575 .inputs = 2,
576 .input = {
577 { 0, "Composite" },
578 { 7, "S-Video" }
579 },
580 .norms = 2,
581 .tvn = {
582 &f50ccir601_lml33,
583 &f60ccir601_lml33,
584 NULL
585 },
586 .jpeg_int = ZR36057_ISR_GIRQ1,
587 .vsync_int = ZR36057_ISR_GIRQ0,
588 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
589 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
590 .gpcs = { 3, 1 },
591 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
592 .gws_not_connected = 1,
fbe60daa 593 .input_mux = 0,
1da177e4
LT		 594 .init = &lml33_init,
595 }, {
596 .type = LML33R10,
597 .name = "LML33R10",
598 .vendor_id = PCI_VENDOR_ID_ELECTRONICDESIGNGMBH,
599 .device_id = PCI_DEVICE_ID_LML_33R10,
600 .i2c_decoder = I2C_DRIVERID_SAA7114,
601 .i2c_encoder = I2C_DRIVERID_ADV7170,
602 .video_codec = CODEC_TYPE_ZR36060,
603
604 .inputs = 2,
605 .input = {
606 { 0, "Composite" },
607 { 7, "S-Video" }
608 },
609 .norms = 2,
610 .tvn = {
611 &f50ccir601_lm33r10,
612 &f60ccir601_lm33r10,
613 NULL
614 },
615 .jpeg_int = ZR36057_ISR_GIRQ1,
616 .vsync_int = ZR36057_ISR_GIRQ0,
617 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
618 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
619 .gpcs = { 3, 1 },
620 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
621 .gws_not_connected = 1,
fbe60daa 622 .input_mux = 0,
1da177e4
LT		 623 .init = &lml33_init,
624 }, {
625 .type = BUZ,
626 .name = "Buz",
627 .vendor_id = PCI_VENDOR_ID_IOMEGA,
628 .device_id = PCI_DEVICE_ID_IOMEGA_BUZ,
629 .i2c_decoder = I2C_DRIVERID_SAA7111A,
630 .i2c_encoder = I2C_DRIVERID_SAA7185B,
631 .video_codec = CODEC_TYPE_ZR36060,
632
633 .inputs = 2,
634 .input = {
635 { 3, "Composite" },
636 { 7, "S-Video" }
637 },
638 .norms = 3,
639 .tvn = {
640 &f50ccir601,
641 &f60ccir601,
642 &f50ccir601
643 },
644 .jpeg_int = ZR36057_ISR_GIRQ1,
645 .vsync_int = ZR36057_ISR_GIRQ0,
646 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
647 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
648 .gpcs = { 3, 1 },
649 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
650 .gws_not_connected = 1,
fbe60daa 651 .input_mux = 0,
1da177e4 652 .init = &buz_init,
fbe60daa
MS		 653 }, {
654 .type = AVS6EYES,
655 .name = "6-Eyes",
656 /* AverMedia chose not to brand the 6-Eyes. Thus it
657 can't be autodetected, and requires card=x. */
658 .vendor_id = -1,
659 .device_id = -1,
660 .i2c_decoder = I2C_DRIVERID_KS0127,
661 .i2c_encoder = I2C_DRIVERID_BT866,
662 .video_codec = CODEC_TYPE_ZR36060,
663
664 .inputs = 10,
665 .input = {
666 { 0, "Composite 1" },
667 { 1, "Composite 2" },
668 { 2, "Composite 3" },
669 { 4, "Composite 4" },
670 { 5, "Composite 5" },
671 { 6, "Composite 6" },
672 { 8, "S-Video 1" },
673 { 9, "S-Video 2" },
674 {10, "S-Video 3" },
675 {15, "YCbCr" }
676 },
677 .norms = 2,
678 .tvn = {
679 &f50ccir601_avs6eyes,
680 &f60ccir601_avs6eyes,
681 NULL
682 },
683 .jpeg_int = ZR36057_ISR_GIRQ1,
684 .vsync_int = ZR36057_ISR_GIRQ0,
685 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
686 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
687 .gpcs = { 3, 1 }, // Validity unknown /Sam
688 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 }, // Validity unknown /Sam
689 .gws_not_connected = 1,
690 .input_mux = 1,
691 .init = &avs6eyes_init,
1da177e4 692 }
fbe60daa 693
1da177e4
LT		 694};
695
696/*
697 * I2C functions
698 */
699/* software I2C functions */
700static int
701zoran_i2c_getsda (void *data)
702{
703 struct zoran *zr = (struct zoran *) data;
704
705 return (btread(ZR36057_I2CBR) >> 1) & 1;
706}
707
708static int
709zoran_i2c_getscl (void *data)
710{
711 struct zoran *zr = (struct zoran *) data;
712
713 return btread(ZR36057_I2CBR) & 1;
714}
715
716static void
717zoran_i2c_setsda (void *data,
718 int state)
719{
720 struct zoran *zr = (struct zoran *) data;
721
722 if (state)
723 zr->i2cbr |= 2;
724 else
725 zr->i2cbr &= ~2;
726 btwrite(zr->i2cbr, ZR36057_I2CBR);
727}
728
729static void
730zoran_i2c_setscl (void *data,
731 int state)
732{
733 struct zoran *zr = (struct zoran *) data;
734
735 if (state)
736 zr->i2cbr |= 1;
737 else
738 zr->i2cbr &= ~1;
739 btwrite(zr->i2cbr, ZR36057_I2CBR);
740}
741
742static int
743zoran_i2c_client_register (struct i2c_client *client)
744{
745 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
746 int res = 0;
747
748 dprintk(2,
749 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
750 ZR_DEVNAME(zr), client->driver->id);
751
384c3689 752 mutex_lock(&zr->resource_lock);
1da177e4
LT		 753
754 if (zr->user > 0) {
755 /* we're already busy, so we keep a reference to
756 * them... Could do a lot of stuff here, but this
757 * is easiest. (Did I ever mention I'm a lazy ass?)
758 */
759 res = -EBUSY;
760 goto clientreg_unlock_and_return;
761 }
762
763 if (client->driver->id == zr->card.i2c_decoder)
764 zr->decoder = client;
765 else if (client->driver->id == zr->card.i2c_encoder)
766 zr->encoder = client;
767 else {
768 res = -ENODEV;
769 goto clientreg_unlock_and_return;
770 }
771
772clientreg_unlock_and_return:
384c3689 773 mutex_unlock(&zr->resource_lock);
1da177e4
LT		 774
775 return res;
776}
777
778static int
779zoran_i2c_client_unregister (struct i2c_client *client)
780{
781 struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
782 int res = 0;
783
784 dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
785
384c3689 786 mutex_lock(&zr->resource_lock);
1da177e4
LT		 787
788 if (zr->user > 0) {
789 res = -EBUSY;
790 goto clientunreg_unlock_and_return;
791 }
792
793 /* try to locate it */
794 if (client == zr->encoder) {
795 zr->encoder = NULL;
796 } else if (client == zr->decoder) {
797 zr->decoder = NULL;
798 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
799 }
800clientunreg_unlock_and_return:
384c3689 801 mutex_unlock(&zr->resource_lock);
1da177e4
LT		 802 return res;
803}
804
6275163e 805static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
1da177e4
LT		 806 .setsda = zoran_i2c_setsda,
807 .setscl = zoran_i2c_setscl,
808 .getsda = zoran_i2c_getsda,
809 .getscl = zoran_i2c_getscl,
810 .udelay = 10,
1da177e4
LT		 811 .timeout = 100,
812};
813
1da177e4
LT		 814static int
815zoran_register_i2c (struct zoran *zr)
816{
817 memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
818 sizeof(struct i2c_algo_bit_data));
819 zr->i2c_algo.data = zr;
6275163e
JD		 820 zr->i2c_adapter.id = I2C_HW_B_ZR36067;
821 zr->i2c_adapter.client_register = zoran_i2c_client_register;
822 zr->i2c_adapter.client_unregister = zoran_i2c_client_unregister;
823 strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
824 sizeof(zr->i2c_adapter.name));
1da177e4
LT		 825 i2c_set_adapdata(&zr->i2c_adapter, zr);
826 zr->i2c_adapter.algo_data = &zr->i2c_algo;
12a917f6 827 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
1da177e4
LT		 828 return i2c_bit_add_bus(&zr->i2c_adapter);
829}
830
831static void
832zoran_unregister_i2c (struct zoran *zr)
833{
3269711b 834 i2c_del_adapter(&zr->i2c_adapter);
1da177e4
LT		 835}
836
837/* Check a zoran_params struct for correctness, insert default params */
838
839int
840zoran_check_jpg_settings (struct zoran *zr,
841 struct zoran_jpg_settings *settings)
842{
843 int err = 0, err0 = 0;
844
845 dprintk(4,
846 KERN_DEBUG
847 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
848 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
849 settings->VerDcm, settings->TmpDcm);
850 dprintk(4,
851 KERN_DEBUG
852 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
853 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
854 settings->img_width, settings->img_height);
855 /* Check decimation, set default values for decimation = 1, 2, 4 */
856 switch (settings->decimation) {
857 case 1:
858
859 settings->HorDcm = 1;
860 settings->VerDcm = 1;
861 settings->TmpDcm = 1;
862 settings->field_per_buff = 2;
863 settings->img_x = 0;
864 settings->img_y = 0;
865 settings->img_width = BUZ_MAX_WIDTH;
866 settings->img_height = BUZ_MAX_HEIGHT / 2;
867 break;
868 case 2:
869
870 settings->HorDcm = 2;
871 settings->VerDcm = 1;
872 settings->TmpDcm = 2;
873 settings->field_per_buff = 1;
874 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
875 settings->img_y = 0;
876 settings->img_width =
877 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
878 settings->img_height = BUZ_MAX_HEIGHT / 2;
879 break;
880 case 4:
881
882 if (zr->card.type == DC10_new) {
883 dprintk(1,
884 KERN_DEBUG
885 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
886 ZR_DEVNAME(zr));
887 err0++;
888 break;
889 }
890
891 settings->HorDcm = 4;
892 settings->VerDcm = 2;
893 settings->TmpDcm = 2;
894 settings->field_per_buff = 1;
895 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
896 settings->img_y = 0;
897 settings->img_width =
898 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
899 settings->img_height = BUZ_MAX_HEIGHT / 2;
900 break;
901 case 0:
902
903 /* We have to check the data the user has set */
904
905 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
906 (zr->card.type == DC10_new || settings->HorDcm != 4))
907 err0++;
908 if (settings->VerDcm != 1 && settings->VerDcm != 2)
909 err0++;
910 if (settings->TmpDcm != 1 && settings->TmpDcm != 2)
911 err0++;
912 if (settings->field_per_buff != 1 &&
913 settings->field_per_buff != 2)
914 err0++;
915 if (settings->img_x < 0)
916 err0++;
917 if (settings->img_y < 0)
918 err0++;
919 if (settings->img_width < 0)
920 err0++;
921 if (settings->img_height < 0)
922 err0++;
923 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH)
924 err0++;
925 if (settings->img_y + settings->img_height >
926 BUZ_MAX_HEIGHT / 2)
927 err0++;
928 if (settings->HorDcm && settings->VerDcm) {
929 if (settings->img_width %
930 (16 * settings->HorDcm) != 0)
931 err0++;
932 if (settings->img_height %
933 (8 * settings->VerDcm) != 0)
934 err0++;
935 }
936
937 if (err0) {
938 dprintk(1,
939 KERN_ERR
940 "%s: check_jpg_settings() - error in params for decimation = 0\n",
941 ZR_DEVNAME(zr));
942 err++;
943 }
944 break;
945 default:
946 dprintk(1,
947 KERN_ERR
948 "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
949 ZR_DEVNAME(zr), settings->decimation);
950 err++;
951 break;
952 }
953
954 if (settings->jpg_comp.quality > 100)
955 settings->jpg_comp.quality = 100;
956 if (settings->jpg_comp.quality < 5)
957 settings->jpg_comp.quality = 5;
958 if (settings->jpg_comp.APPn < 0)
959 settings->jpg_comp.APPn = 0;
960 if (settings->jpg_comp.APPn > 15)
961 settings->jpg_comp.APPn = 15;
962 if (settings->jpg_comp.APP_len < 0)
963 settings->jpg_comp.APP_len = 0;
964 if (settings->jpg_comp.APP_len > 60)
965 settings->jpg_comp.APP_len = 60;
966 if (settings->jpg_comp.COM_len < 0)
967 settings->jpg_comp.COM_len = 0;
968 if (settings->jpg_comp.COM_len > 60)
969 settings->jpg_comp.COM_len = 60;
970 if (err)
971 return -EINVAL;
972 return 0;
973}
974
975void
976zoran_open_init_params (struct zoran *zr)
977{
978 int i;
979
980 /* User must explicitly set a window */
981 zr->overlay_settings.is_set = 0;
982 zr->overlay_mask = NULL;
983 zr->overlay_active = ZORAN_FREE;
984
985 zr->v4l_memgrab_active = 0;
986 zr->v4l_overlay_active = 0;
987 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
988 zr->v4l_grab_seq = 0;
989 zr->v4l_settings.width = 192;
990 zr->v4l_settings.height = 144;
c014ec90 991 zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */
1da177e4
LT		 992 zr->v4l_settings.bytesperline =
993 zr->v4l_settings.width *
994 ((zr->v4l_settings.format->depth + 7) / 8);
995
996 /* DMA ring stuff for V4L */
997 zr->v4l_pend_tail = 0;
998 zr->v4l_pend_head = 0;
999 zr->v4l_sync_tail = 0;
1000 zr->v4l_buffers.active = ZORAN_FREE;
1001 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1002 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1003 }
1004 zr->v4l_buffers.allocated = 0;
1005
1006 for (i = 0; i < BUZ_MAX_FRAME; i++) {
1007 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
1008 }
1009 zr->jpg_buffers.active = ZORAN_FREE;
1010 zr->jpg_buffers.allocated = 0;
1011 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
1012 zr->jpg_settings.decimation = 1;
1013 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
1014 if (zr->card.type != BUZ)
1015 zr->jpg_settings.odd_even = 1;
1016 else
1017 zr->jpg_settings.odd_even = 0;
1018 zr->jpg_settings.jpg_comp.APPn = 0;
1019 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
1020 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
1021 sizeof(zr->jpg_settings.jpg_comp.APP_data));
1022 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
1023 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
1024 sizeof(zr->jpg_settings.jpg_comp.COM_data));
1025 zr->jpg_settings.jpg_comp.jpeg_markers =
1026 JPEG_MARKER_DHT | JPEG_MARKER_DQT;
1027 i = zoran_check_jpg_settings(zr, &zr->jpg_settings);
1028 if (i)
1029 dprintk(1,
1030 KERN_ERR
1031 "%s: zoran_open_init_params() internal error\n",
1032 ZR_DEVNAME(zr));
1033
1034 clear_interrupt_counters(zr);
1035 zr->testing = 0;
1036}
1037
1038static void __devinit
1039test_interrupts (struct zoran *zr)
1040{
1041 DEFINE_WAIT(wait);
1042 int timeout, icr;
1043
1044 clear_interrupt_counters(zr);
1045
1046 zr->testing = 1;
1047 icr = btread(ZR36057_ICR);
1048 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
1049 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
1050 timeout = schedule_timeout(HZ);
1051 finish_wait(&zr->test_q, &wait);
1052 btwrite(0, ZR36057_ICR);
1053 btwrite(0x78000000, ZR36057_ISR);
1054 zr->testing = 0;
1055 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
1056 if (timeout) {
1057 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
1058 }
18b548ca 1059 if (zr36067_debug > 1)
1da177e4
LT		 1060 print_interrupts(zr);
1061 btwrite(icr, ZR36057_ICR);
1062}
1063
1064static int __devinit
1065zr36057_init (struct zoran *zr)
1066{
daf72f40 1067 int j, err;
1da177e4
LT		 1068 int two = 2;
1069 int zero = 0;
1070
1071 dprintk(1,
1072 KERN_INFO
1073 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1074 ZR_DEVNAME(zr), zr->id, zr);
1075
1076 /* default setup of all parameters which will persist between opens */
1077 zr->user = 0;
1078
1079 init_waitqueue_head(&zr->v4l_capq);
1080 init_waitqueue_head(&zr->jpg_capq);
1081 init_waitqueue_head(&zr->test_q);
1082 zr->jpg_buffers.allocated = 0;
1083 zr->v4l_buffers.allocated = 0;
1084
1085 zr->buffer.base = (void *) vidmem;
1086 zr->buffer.width = 0;
1087 zr->buffer.height = 0;
1088 zr->buffer.depth = 0;
1089 zr->buffer.bytesperline = 0;
1090
1091 /* Avoid nonsense settings from user for default input/norm */
1092 if (default_norm < VIDEO_MODE_PAL &&
1093 default_norm > VIDEO_MODE_SECAM)
1094 default_norm = VIDEO_MODE_PAL;
1095 zr->norm = default_norm;
1096 if (!(zr->timing = zr->card.tvn[zr->norm])) {
1097 dprintk(1,
1098 KERN_WARNING
1099 "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1100 ZR_DEVNAME(zr));
1101 zr->norm = VIDEO_MODE_PAL;
1102 zr->timing = zr->card.tvn[zr->norm];
1103 }
1104
60e3cac4
TP		 1105 if (default_input > zr->card.inputs-1) {
1106 dprintk(1,
1107 KERN_WARNING
1108 "%s: default_input value %d out of range (0-%d)\n",
1109 ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1110 default_input = 0;
1111 }
1112 zr->input = default_input;
1da177e4
LT		 1113
1114 /* Should the following be reset at every open ? */
1115 zr->hue = 32768;
1116 zr->contrast = 32768;
1117 zr->saturation = 32768;
1118 zr->brightness = 32768;
1119
1120 /* default setup (will be repeated at every open) */
1121 zoran_open_init_params(zr);
1122
1123 /* allocate memory *before* doing anything to the hardware
1124 * in case allocation fails */
daf72f40
JD		 1125 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1126 zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1127 if (!zr->stat_com || !zr->video_dev) {
1da177e4
LT		 1128 dprintk(1,
1129 KERN_ERR
1130 "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1131 ZR_DEVNAME(zr));
daf72f40
JD		 1132 err = -ENOMEM;
1133 goto exit_free;
1da177e4 1134 }
1da177e4 1135 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
9c169df8 1136 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1da177e4
LT		 1137 }
1138
1139 /*
1140 * Now add the template and register the device unit.
1141 */
1da177e4
LT		 1142 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
1143 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
60e3cac4 1144 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
daf72f40
JD		 1145 if (err < 0)
1146 goto exit_unregister;
1da177e4
LT		 1147
1148 zoran_init_hardware(zr);
18b548ca 1149 if (zr36067_debug > 2)
1da177e4
LT		 1150 detect_guest_activity(zr);
1151 test_interrupts(zr);
1152 if (!pass_through) {
1153 decoder_command(zr, DECODER_ENABLE_OUTPUT, &zero);
1154 encoder_command(zr, ENCODER_SET_INPUT, &two);
1155 }
1156
1157 zr->zoran_proc = NULL;
1158 zr->initialized = 1;
1159 return 0;
daf72f40
JD		 1160
1161exit_unregister:
1162 zoran_unregister_i2c(zr);
1163exit_free:
1164 kfree(zr->stat_com);
1165 kfree(zr->video_dev);
1166 return err;
1da177e4
LT		 1167}
1168
1169static void
1170zoran_release (struct zoran *zr)
1171{
1172 if (!zr->initialized)
85b9b8a4 1173 goto exit_free;
1da177e4
LT		 1174 /* unregister videocodec bus */
1175 if (zr->codec) {
1176 struct videocodec_master *master = zr->codec->master_data;
2ea75330 1177
1da177e4 1178 videocodec_detach(zr->codec);
2ea75330 1179 kfree(master);
1da177e4
LT		 1180 }
1181 if (zr->vfe) {
1182 struct videocodec_master *master = zr->vfe->master_data;
2ea75330 1183
1da177e4 1184 videocodec_detach(zr->vfe);
2ea75330 1185 kfree(master);
1da177e4
LT		 1186 }
1187
1188 /* unregister i2c bus */
1189 zoran_unregister_i2c(zr);
1190 /* disable PCI bus-mastering */
1191 zoran_set_pci_master(zr, 0);
1192 /* put chip into reset */
1193 btwrite(0, ZR36057_SPGPPCR);
1194 free_irq(zr->pci_dev->irq, zr);
1195 /* unmap and free memory */
daf72f40 1196 kfree(zr->stat_com);
1da177e4
LT		 1197 zoran_proc_cleanup(zr);
1198 iounmap(zr->zr36057_mem);
1199 pci_disable_device(zr->pci_dev);
1200 video_unregister_device(zr->video_dev);
85b9b8a4
JD		 1201exit_free:
1202 kfree(zr);
1da177e4
LT		 1203}
1204
1205void
1206zoran_vdev_release (struct video_device *vdev)
1207{
1208 kfree(vdev);
1209}
1210
1211static struct videocodec_master * __devinit
1212zoran_setup_videocodec (struct zoran *zr,
1213 int type)
1214{
1215 struct videocodec_master *m = NULL;
1216
1217 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1218 if (!m) {
1219 dprintk(1,
1220 KERN_ERR
1221 "%s: zoran_setup_videocodec() - no memory\n",
1222 ZR_DEVNAME(zr));
1223 return m;
1224 }
1225
22c4a4e9
MCC		 1226 /* magic and type are unused for master struct. Makes sense only at
1227 codec structs.
1228 In the past, .type were initialized to the old V4L1 .hardware
1229 value, as VID_HARDWARE_ZR36067
1230 */
1231 m->magic = 0L;
1232 m->type = 0;
1233
1da177e4
LT		 1234 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1235 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1236 m->data = zr;
1237
1238 switch (type)
1239 {
1240 case CODEC_TYPE_ZR36060:
1241 m->readreg = zr36060_read;
1242 m->writereg = zr36060_write;
1243 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1244 break;
1245 case CODEC_TYPE_ZR36050:
1246 m->readreg = zr36050_read;
1247 m->writereg = zr36050_write;
1248 m->flags |= CODEC_FLAG_JPEG;
1249 break;
1250 case CODEC_TYPE_ZR36016:
1251 m->readreg = zr36016_read;
1252 m->writereg = zr36016_write;
1253 m->flags |= CODEC_FLAG_VFE;
1254 break;
1255 }
1256
1257 return m;
1258}
1259
1260/*
c84e6036 1261 * Scan for a Buz card (actually for the PCI controller ZR36057),
1da177e4
LT		 1262 * request the irq and map the io memory
1263 */
1264static int __devinit
1265find_zr36057 (void)
1266{
1267 unsigned char latency, need_latency;
1268 struct zoran *zr;
1269 struct pci_dev *dev = NULL;
1270 int result;
1271 struct videocodec_master *master_vfe = NULL;
1272 struct videocodec_master *master_codec = NULL;
1273 int card_num;
1274 char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
1275
1276 zoran_num = 0;
1277 while (zoran_num < BUZ_MAX &&
e491cbc8 1278 (dev = pci_get_device(PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36057, dev)) != NULL) {
1da177e4 1279 card_num = card[zoran_num];
85b9b8a4
JD		 1280 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1281 if (!zr) {
1282 dprintk(1,
1283 KERN_ERR
1284 "%s: find_zr36057() - kzalloc failed\n",
1285 ZORAN_NAME);
1286 continue;
1287 }
1da177e4
LT		 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 1294 if (pci_enable_device(dev))
85b9b8a4 1295 goto zr_free_mem;
1da177e4
LT		 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));
85b9b8a4 1311 goto zr_free_mem;
1da177e4
LT		 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));
85b9b8a4 1350 goto zr_free_mem;
1da177e4
LT		 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);
85b9b8a4 1360 goto zr_free_mem;
1da177e4
LT		 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));
85b9b8a4 1378 goto zr_free_mem;
1da177e4
LT		 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);
85b9b8a4 1547 zoran[zoran_num++] = zr;
1da177e4
LT		 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);
85b9b8a4
JD		 1566 zr_free_mem:
1567 kfree(zr);
1da177e4
LT		 1568 continue;
1569 }
e491cbc8
AC		 1570 if (dev) /* Clean up ref count on early exit */
1571 pci_dev_put(dev);
1572
1da177e4
LT		 1573 if (zoran_num == 0) {
1574 dprintk(1, KERN_INFO "No known MJPEG cards found.\n");
1575 }
1576 return zoran_num;
1577}
1578
1579static int __init
1580init_dc10_cards (void)
1581{
1582 int i;
1583
1584 memset(zoran, 0, sizeof(zoran));
1585 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1586 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1587
1588 /* Look for cards */
1589 if (find_zr36057() < 0) {
1590 return -EIO;
1591 }
1592 if (zoran_num == 0)
1593 return -ENODEV;
1594 dprintk(1, KERN_INFO "%s: %d card(s) found\n", ZORAN_NAME,
1595 zoran_num);
1596 /* check the parameters we have been given, adjust if necessary */
1597 if (v4l_nbufs < 2)
1598 v4l_nbufs = 2;
1599 if (v4l_nbufs > VIDEO_MAX_FRAME)
1600 v4l_nbufs = VIDEO_MAX_FRAME;
1601 /* The user specfies the in KB, we want them in byte
1602 * (and page aligned) */
1603 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1604 if (v4l_bufsize < 32768)
1605 v4l_bufsize = 32768;
1606 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1607 if (v4l_bufsize > 2048 * 1024)
1608 v4l_bufsize = 2048 * 1024;
1609 if (jpg_nbufs < 4)
1610 jpg_nbufs = 4;
1611 if (jpg_nbufs > BUZ_MAX_FRAME)
1612 jpg_nbufs = BUZ_MAX_FRAME;
1613 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1614 if (jpg_bufsize < 8192)
1615 jpg_bufsize = 8192;
1616 if (jpg_bufsize > (512 * 1024))
1617 jpg_bufsize = 512 * 1024;
1618 /* Use parameter for vidmem or try to find a video card */
1619 if (vidmem) {
1620 dprintk(1,
1621 KERN_INFO
1622 "%s: Using supplied video memory base address @ 0x%lx\n",
1623 ZORAN_NAME, vidmem);
1624 }
1625
1626 /* random nonsense */
18b548ca 1627 dprintk(6, KERN_DEBUG "Jotti is een held!\n");
1da177e4
LT		 1628
1629 /* some mainboards might not do PCI-PCI data transfer well */
e355880b 1630 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1da177e4
LT		 1631 dprintk(1,
1632 KERN_WARNING
e355880b 1633 "%s: chipset does not support reliable PCI-PCI DMA\n",
1da177e4
LT		 1634 ZORAN_NAME);
1635 }
1636
1637 /* take care of Natoma chipset and a revision 1 zr36057 */
1638 for (i = 0; i < zoran_num; i++) {
85b9b8a4 1639 struct zoran *zr = zoran[i];
1da177e4 1640
e355880b 1641 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1da177e4
LT		 1642 zr->jpg_buffers.need_contiguous = 1;
1643 dprintk(1,
1644 KERN_INFO
1645 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1646 ZR_DEVNAME(zr));
1647 }
1648
1649 if (zr36057_init(zr) < 0) {
1650 for (i = 0; i < zoran_num; i++)
85b9b8a4 1651 zoran_release(zoran[i]);
1da177e4
LT		 1652 return -EIO;
1653 }
1654 zoran_proc_init(zr);
1655 }
1656
1657 return 0;
1658}
1659
1660static void __exit
1661unload_dc10_cards (void)
1662{
1663 int i;
1664
1665 for (i = 0; i < zoran_num; i++)
85b9b8a4 1666 zoran_release(zoran[i]);
1da177e4
LT		 1667}
1668
1669module_init(init_dc10_cards);
1670module_exit(unload_dc10_cards);
Linux 6.x block layer and io_uring tree(s)