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