projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (10733): zoran: increase bufsize to a value suitable for 768x576.
[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>
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>
384c3689 50#include <linux/mutex.h>
1da177e4
LT		 51
52#include <asm/io.h>
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{
257 dprintk(3, KERN_DEBUG "%s: dc10_init()\n", ZR_DEVNAME(zr));
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{
269 dprintk(3, KERN_DEBUG "%s: dc10plus_init()\n", ZR_DEVNAME(zr));
270}
271
272static void
273buz_init (struct zoran *zr)
274{
275 dprintk(3, KERN_DEBUG "%s: buz_init()\n", ZR_DEVNAME(zr));
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{
286 dprintk(3, KERN_DEBUG "%s: lml33_init()\n", ZR_DEVNAME(zr));
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 735 zr->i2c_adapter.id = I2C_HW_B_ZR36067;
6275163e
JD		 736 strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
737 sizeof(zr->i2c_adapter.name));
0ab6e1c3 738 i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
1da177e4 739 zr->i2c_adapter.algo_data = &zr->i2c_algo;
12a917f6 740 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
1da177e4
LT		 741 return i2c_bit_add_bus(&zr->i2c_adapter);
742}
743
744static void
745zoran_unregister_i2c (struct zoran *zr)
746{
3269711b 747 i2c_del_adapter(&zr->i2c_adapter);
1da177e4
LT		 748}
749
750/* Check a zoran_params struct for correctness, insert default params */
751
752int
753zoran_check_jpg_settings (struct zoran *zr,
0ba514d5
HV		 754 struct zoran_jpg_settings *settings,
755 int try)
1da177e4
LT		 756{
757 int err = 0, err0 = 0;
758
759 dprintk(4,
760 KERN_DEBUG
761 "%s: check_jpg_settings() - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
762 ZR_DEVNAME(zr), settings->decimation, settings->HorDcm,
763 settings->VerDcm, settings->TmpDcm);
764 dprintk(4,
765 KERN_DEBUG
766 "%s: check_jpg_settings() - x: %d, y: %d, w: %d, y: %d\n",
767 ZR_DEVNAME(zr), settings->img_x, settings->img_y,
768 settings->img_width, settings->img_height);
769 /* Check decimation, set default values for decimation = 1, 2, 4 */
770 switch (settings->decimation) {
771 case 1:
772
773 settings->HorDcm = 1;
774 settings->VerDcm = 1;
775 settings->TmpDcm = 1;
776 settings->field_per_buff = 2;
777 settings->img_x = 0;
778 settings->img_y = 0;
779 settings->img_width = BUZ_MAX_WIDTH;
780 settings->img_height = BUZ_MAX_HEIGHT / 2;
781 break;
782 case 2:
783
784 settings->HorDcm = 2;
785 settings->VerDcm = 1;
786 settings->TmpDcm = 2;
787 settings->field_per_buff = 1;
788 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
789 settings->img_y = 0;
790 settings->img_width =
791 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
792 settings->img_height = BUZ_MAX_HEIGHT / 2;
793 break;
794 case 4:
795
796 if (zr->card.type == DC10_new) {
797 dprintk(1,
798 KERN_DEBUG
799 "%s: check_jpg_settings() - HDec by 4 is not supported on the DC10\n",
800 ZR_DEVNAME(zr));
801 err0++;
802 break;
803 }
804
805 settings->HorDcm = 4;
806 settings->VerDcm = 2;
807 settings->TmpDcm = 2;
808 settings->field_per_buff = 1;
809 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
810 settings->img_y = 0;
811 settings->img_width =
812 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
813 settings->img_height = BUZ_MAX_HEIGHT / 2;
814 break;
815 case 0:
816
817 /* We have to check the data the user has set */
818
819 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
0ba514d5
HV		 820 (zr->card.type == DC10_new || settings->HorDcm != 4)) {
821 settings->HorDcm = clamp(settings->HorDcm, 1, 2);
1da177e4 822 err0++;
0ba514d5
HV		 823 }
824 if (settings->VerDcm != 1 && settings->VerDcm != 2) {
825 settings->VerDcm = clamp(settings->VerDcm, 1, 2);
1da177e4 826 err0++;
0ba514d5
HV		 827 }
828 if (settings->TmpDcm != 1 && settings->TmpDcm != 2) {
829 settings->TmpDcm = clamp(settings->TmpDcm, 1, 2);
1da177e4 830 err0++;
0ba514d5 831 }
1da177e4 832 if (settings->field_per_buff != 1 &&
0ba514d5
HV		 833 settings->field_per_buff != 2) {
834 settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
1da177e4 835 err0++;
0ba514d5
HV		 836 }
837 if (settings->img_x < 0) {
838 settings->img_x = 0;
1da177e4 839 err0++;
0ba514d5
HV		 840 }
841 if (settings->img_y < 0) {
842 settings->img_y = 0;
1da177e4 843 err0++;
0ba514d5
HV		 844 }
845 if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
846 settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
1da177e4 847 err0++;
0ba514d5
HV		 848 }
849 if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
850 settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
1da177e4 851 err0++;
0ba514d5
HV		 852 }
853 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
854 settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
855 err0++;
856 }
857 if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
858 settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
1da177e4 859 err0++;
0ba514d5
HV		 860 }
861 if (settings->img_width % (16 * settings->HorDcm) != 0) {
862 settings->img_width -= settings->img_width % (16 * settings->HorDcm);
863 if (settings->img_width == 0)
864 settings->img_width = 16 * settings->HorDcm;
865 err0++;
866 }
867 if (settings->img_height % (8 * settings->VerDcm) != 0) {
868 settings->img_height -= settings->img_height % (8 * settings->VerDcm);
869 if (settings->img_height == 0)
870 settings->img_height = 8 * settings->VerDcm;
1da177e4 871 err0++;
1da177e4
LT		 872 }
873
0ba514d5 874 if (!try && err0) {
1da177e4
LT		 875 dprintk(1,
876 KERN_ERR
877 "%s: check_jpg_settings() - error in params for decimation = 0\n",
878 ZR_DEVNAME(zr));
879 err++;
880 }
881 break;
882 default:
883 dprintk(1,
884 KERN_ERR
885 "%s: check_jpg_settings() - decimation = %d, must be 0, 1, 2 or 4\n",
886 ZR_DEVNAME(zr), settings->decimation);
887 err++;
888 break;
889 }
890
891 if (settings->jpg_comp.quality > 100)
892 settings->jpg_comp.quality = 100;
893 if (settings->jpg_comp.quality < 5)
894 settings->jpg_comp.quality = 5;
895 if (settings->jpg_comp.APPn < 0)
896 settings->jpg_comp.APPn = 0;
897 if (settings->jpg_comp.APPn > 15)
898 settings->jpg_comp.APPn = 15;
899 if (settings->jpg_comp.APP_len < 0)
900 settings->jpg_comp.APP_len = 0;
901 if (settings->jpg_comp.APP_len > 60)
902 settings->jpg_comp.APP_len = 60;
903 if (settings->jpg_comp.COM_len < 0)
904 settings->jpg_comp.COM_len = 0;
905 if (settings->jpg_comp.COM_len > 60)
906 settings->jpg_comp.COM_len = 60;
907 if (err)
908 return -EINVAL;
909 return 0;
910}
911
912void
913zoran_open_init_params (struct zoran *zr)
914{
915 int i;
916
917 /* User must explicitly set a window */
918 zr->overlay_settings.is_set = 0;
919 zr->overlay_mask = NULL;
920 zr->overlay_active = ZORAN_FREE;
921
922 zr->v4l_memgrab_active = 0;
923 zr->v4l_overlay_active = 0;
924 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
925 zr->v4l_grab_seq = 0;
926 zr->v4l_settings.width = 192;
927 zr->v4l_settings.height = 144;
c014ec90 928 zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */
1da177e4
LT		 929 zr->v4l_settings.bytesperline =
930 zr->v4l_settings.width *
931 ((zr->v4l_settings.format->depth + 7) / 8);
932
933 /* DMA ring stuff for V4L */
934 zr->v4l_pend_tail = 0;
935 zr->v4l_pend_head = 0;
936 zr->v4l_sync_tail = 0;
937 zr->v4l_buffers.active = ZORAN_FREE;
938 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
939 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
940 }
941 zr->v4l_buffers.allocated = 0;
942
943 for (i = 0; i < BUZ_MAX_FRAME; i++) {
944 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
945 }
946 zr->jpg_buffers.active = ZORAN_FREE;
947 zr->jpg_buffers.allocated = 0;
948 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
949 zr->jpg_settings.decimation = 1;
950 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
951 if (zr->card.type != BUZ)
952 zr->jpg_settings.odd_even = 1;
953 else
954 zr->jpg_settings.odd_even = 0;
955 zr->jpg_settings.jpg_comp.APPn = 0;
956 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
957 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
958 sizeof(zr->jpg_settings.jpg_comp.APP_data));
959 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
960 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
961 sizeof(zr->jpg_settings.jpg_comp.COM_data));
962 zr->jpg_settings.jpg_comp.jpeg_markers =
963 JPEG_MARKER_DHT | JPEG_MARKER_DQT;
0ba514d5 964 i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
1da177e4
LT		 965 if (i)
966 dprintk(1,
967 KERN_ERR
968 "%s: zoran_open_init_params() internal error\n",
969 ZR_DEVNAME(zr));
970
971 clear_interrupt_counters(zr);
972 zr->testing = 0;
973}
974
975static void __devinit
976test_interrupts (struct zoran *zr)
977{
978 DEFINE_WAIT(wait);
979 int timeout, icr;
980
981 clear_interrupt_counters(zr);
982
983 zr->testing = 1;
984 icr = btread(ZR36057_ICR);
985 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
986 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
987 timeout = schedule_timeout(HZ);
988 finish_wait(&zr->test_q, &wait);
989 btwrite(0, ZR36057_ICR);
990 btwrite(0x78000000, ZR36057_ISR);
991 zr->testing = 0;
992 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
993 if (timeout) {
994 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
995 }
18b548ca 996 if (zr36067_debug > 1)
1da177e4
LT		 997 print_interrupts(zr);
998 btwrite(icr, ZR36057_ICR);
999}
1000
1001static int __devinit
1002zr36057_init (struct zoran *zr)
1003{
daf72f40 1004 int j, err;
1da177e4
LT		 1005
1006 dprintk(1,
1007 KERN_INFO
1008 "%s: zr36057_init() - initializing card[%d], zr=%p\n",
1009 ZR_DEVNAME(zr), zr->id, zr);
1010
1011 /* default setup of all parameters which will persist between opens */
1012 zr->user = 0;
1013
1014 init_waitqueue_head(&zr->v4l_capq);
1015 init_waitqueue_head(&zr->jpg_capq);
1016 init_waitqueue_head(&zr->test_q);
1017 zr->jpg_buffers.allocated = 0;
1018 zr->v4l_buffers.allocated = 0;
1019
7f6adeaf
HV		 1020 zr->vbuf_base = (void *) vidmem;
1021 zr->vbuf_width = 0;
1022 zr->vbuf_height = 0;
1023 zr->vbuf_depth = 0;
1024 zr->vbuf_bytesperline = 0;
1da177e4
LT		 1025
1026 /* Avoid nonsense settings from user for default input/norm */
7f6adeaf
HV		 1027 if (default_norm < 0 && default_norm > 2)
1028 default_norm = 0;
1029 if (default_norm == 0) {
107063c6
HV		 1030 zr->norm = V4L2_STD_PAL;
1031 zr->timing = zr->card.tvn[0];
7f6adeaf 1032 } else if (default_norm == 1) {
107063c6
HV		 1033 zr->norm = V4L2_STD_NTSC;
1034 zr->timing = zr->card.tvn[1];
1035 } else {
1036 zr->norm = V4L2_STD_SECAM;
1037 zr->timing = zr->card.tvn[2];
1038 }
1039 if (zr->timing == NULL) {
1da177e4
LT		 1040 dprintk(1,
1041 KERN_WARNING
1042 "%s: zr36057_init() - default TV standard not supported by hardware. PAL will be used.\n",
1043 ZR_DEVNAME(zr));
107063c6
HV		 1044 zr->norm = V4L2_STD_PAL;
1045 zr->timing = zr->card.tvn[0];
1da177e4
LT		 1046 }
1047
60e3cac4
TP		 1048 if (default_input > zr->card.inputs-1) {
1049 dprintk(1,
1050 KERN_WARNING
1051 "%s: default_input value %d out of range (0-%d)\n",
1052 ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1053 default_input = 0;
1054 }
1055 zr->input = default_input;
1da177e4 1056
1da177e4
LT		 1057 /* default setup (will be repeated at every open) */
1058 zoran_open_init_params(zr);
1059
1060 /* allocate memory *before* doing anything to the hardware
1061 * in case allocation fails */
daf72f40
JD		 1062 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1063 zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1064 if (!zr->stat_com || !zr->video_dev) {
1da177e4
LT		 1065 dprintk(1,
1066 KERN_ERR
1067 "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
1068 ZR_DEVNAME(zr));
daf72f40
JD		 1069 err = -ENOMEM;
1070 goto exit_free;
1da177e4 1071 }
1da177e4 1072 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
9c169df8 1073 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1da177e4
LT		 1074 }
1075
1076 /*
1077 * Now add the template and register the device unit.
1078 */
1da177e4 1079 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
aff88bca 1080 zr->video_dev->parent = &zr->pci_dev->dev;
1da177e4 1081 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
60e3cac4 1082 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
daf72f40 1083 if (err < 0)
66aa66ea 1084 goto exit_free;
601139e0 1085 video_set_drvdata(zr->video_dev, zr);
1da177e4
LT		 1086
1087 zoran_init_hardware(zr);
18b548ca 1088 if (zr36067_debug > 2)
1da177e4
LT		 1089 detect_guest_activity(zr);
1090 test_interrupts(zr);
1091 if (!pass_through) {
107063c6
HV		 1092 struct v4l2_routing route = { 2, 0 };
1093
0ab6e1c3
HV		 1094 decoder_call(zr, video, s_stream, 0);
1095 encoder_call(zr, video, s_routing, &route);
1da177e4
LT		 1096 }
1097
1098 zr->zoran_proc = NULL;
1099 zr->initialized = 1;
1100 return 0;
daf72f40 1101
daf72f40
JD		 1102exit_free:
1103 kfree(zr->stat_com);
1104 kfree(zr->video_dev);
1105 return err;
1da177e4
LT		 1106}
1107
66aa66ea 1108static void __devexit zoran_remove(struct pci_dev *pdev)
1da177e4 1109{
0ab6e1c3
HV		 1110 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1111 struct zoran *zr = to_zoran(v4l2_dev);
66aa66ea 1112
1da177e4 1113 if (!zr->initialized)
85b9b8a4 1114 goto exit_free;
66aa66ea 1115
1da177e4
LT		 1116 /* unregister videocodec bus */
1117 if (zr->codec) {
1118 struct videocodec_master *master = zr->codec->master_data;
2ea75330 1119
1da177e4 1120 videocodec_detach(zr->codec);
2ea75330 1121 kfree(master);
1da177e4
LT		 1122 }
1123 if (zr->vfe) {
1124 struct videocodec_master *master = zr->vfe->master_data;
2ea75330 1125
1da177e4 1126 videocodec_detach(zr->vfe);
2ea75330 1127 kfree(master);
1da177e4
LT		 1128 }
1129
1130 /* unregister i2c bus */
1131 zoran_unregister_i2c(zr);
1132 /* disable PCI bus-mastering */
1133 zoran_set_pci_master(zr, 0);
1134 /* put chip into reset */
1135 btwrite(0, ZR36057_SPGPPCR);
1136 free_irq(zr->pci_dev->irq, zr);
1137 /* unmap and free memory */
daf72f40 1138 kfree(zr->stat_com);
1da177e4
LT		 1139 zoran_proc_cleanup(zr);
1140 iounmap(zr->zr36057_mem);
1141 pci_disable_device(zr->pci_dev);
1142 video_unregister_device(zr->video_dev);
85b9b8a4 1143exit_free:
0ab6e1c3 1144 v4l2_device_unregister(&zr->v4l2_dev);
85b9b8a4 1145 kfree(zr);
1da177e4
LT		 1146}
1147
1148void
1149zoran_vdev_release (struct video_device *vdev)
1150{
1151 kfree(vdev);
1152}
1153
1154static struct videocodec_master * __devinit
1155zoran_setup_videocodec (struct zoran *zr,
1156 int type)
1157{
1158 struct videocodec_master *m = NULL;
1159
1160 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1161 if (!m) {
1162 dprintk(1,
1163 KERN_ERR
1164 "%s: zoran_setup_videocodec() - no memory\n",
1165 ZR_DEVNAME(zr));
1166 return m;
1167 }
1168
22c4a4e9
MCC		 1169 /* magic and type are unused for master struct. Makes sense only at
1170 codec structs.
1171 In the past, .type were initialized to the old V4L1 .hardware
1172 value, as VID_HARDWARE_ZR36067
1173 */
1174 m->magic = 0L;
1175 m->type = 0;
1176
1da177e4
LT		 1177 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1178 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1179 m->data = zr;
1180
1181 switch (type)
1182 {
1183 case CODEC_TYPE_ZR36060:
1184 m->readreg = zr36060_read;
1185 m->writereg = zr36060_write;
1186 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1187 break;
1188 case CODEC_TYPE_ZR36050:
1189 m->readreg = zr36050_read;
1190 m->writereg = zr36050_write;
1191 m->flags |= CODEC_FLAG_JPEG;
1192 break;
1193 case CODEC_TYPE_ZR36016:
1194 m->readreg = zr36016_read;
1195 m->writereg = zr36016_write;
1196 m->flags |= CODEC_FLAG_VFE;
1197 break;
1198 }
1199
1200 return m;
1201}
1202
1203/*
c84e6036 1204 * Scan for a Buz card (actually for the PCI controller ZR36057),
1da177e4
LT		 1205 * request the irq and map the io memory
1206 */
66aa66ea
TP		 1207static int __devinit zoran_probe(struct pci_dev *pdev,
1208 const struct pci_device_id *ent)
1da177e4
LT		 1209{
1210 unsigned char latency, need_latency;
1211 struct zoran *zr;
1da177e4
LT		 1212 int result;
1213 struct videocodec_master *master_vfe = NULL;
1214 struct videocodec_master *master_codec = NULL;
1215 int card_num;
0ab6e1c3 1216 char *codec_name, *vfe_name;
66aa66ea 1217 unsigned int nr;
1da177e4 1218
1da177e4 1219
601139e0 1220 nr = zoran_num++;
66aa66ea
TP		 1221 if (nr >= BUZ_MAX) {
1222 dprintk(1,
1223 KERN_ERR
1224 "%s: driver limited to %d card(s) maximum\n",
1225 ZORAN_NAME, BUZ_MAX);
1226 return -ENOENT;
1227 }
1da177e4 1228
66aa66ea
TP		 1229 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1230 if (!zr) {
1231 dprintk(1,
1232 KERN_ERR
1233 "%s: find_zr36057() - kzalloc failed\n",
1234 ZORAN_NAME);
66aa66ea
TP		 1235 return -ENOMEM;
1236 }
0ab6e1c3
HV		 1237 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1238 goto zr_free_mem;
66aa66ea
TP		 1239 zr->pci_dev = pdev;
1240 zr->id = nr;
1241 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1242 spin_lock_init(&zr->spinlock);
1243 mutex_init(&zr->resource_lock);
1244 if (pci_enable_device(pdev))
0ab6e1c3 1245 goto zr_unreg;
66aa66ea 1246 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION, &zr->revision);
17faeb20
TP		 1247
1248 dprintk(1,
1249 KERN_INFO
5e098b66 1250 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
17faeb20 1251 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision,
5e098b66 1252 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
17faeb20 1253 if (zr->revision >= 2) {
66aa66ea
TP		 1254 dprintk(1,
1255 KERN_INFO
17faeb20
TP		 1256 "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1257 ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor,
1258 zr->pci_dev->subsystem_device);
1259 }
1da177e4 1260
17faeb20
TP		 1261 /* Use auto-detected card type? */
1262 if (card[nr] == -1) {
1263 if (zr->revision < 2) {
1da177e4
LT		 1264 dprintk(1,
1265 KERN_ERR
17faeb20
TP		 1266 "%s: No card type specified, please use the card=X module parameter\n",
1267 ZR_DEVNAME(zr));
1268 dprintk(1,
1269 KERN_ERR
1270 "%s: It is not possible to auto-detect ZR36057 based cards\n",
1da177e4 1271 ZR_DEVNAME(zr));
0ab6e1c3 1272 goto zr_unreg;
1da177e4
LT		 1273 }
1274
17faeb20
TP		 1275 card_num = ent->driver_data;
1276 if (card_num >= NUM_CARDS) {
1277 dprintk(1,
1278 KERN_ERR
1279 "%s: Unknown card, try specifying card=X module parameter\n",
66aa66ea 1280 ZR_DEVNAME(zr));
0ab6e1c3 1281 goto zr_unreg;
17faeb20
TP		 1282 }
1283 dprintk(3,
1284 KERN_DEBUG
1285 "%s: %s() - card %s detected\n",
1286 ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name);
1287 } else {
1288 card_num = card[nr];
1289 if (card_num >= NUM_CARDS || card_num < 0) {
1290 dprintk(1,
1291 KERN_ERR
1292 "%s: User specified card type %d out of range (0 .. %d)\n",
1293 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
0ab6e1c3 1294 goto zr_unreg;
1da177e4 1295 }
66aa66ea 1296 }
1da177e4 1297
66aa66ea
TP		 1298 /* even though we make this a non pointer and thus
1299 * theoretically allow for making changes to this struct
1300 * on a per-individual card basis at runtime, this is
1301 * strongly discouraged. This structure is intended to
1302 * keep general card information, no settings or anything */
1303 zr->card = zoran_cards[card_num];
1304 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1305 "%s[%u]", zr->card.name, zr->id);
1306
5e098b66 1307 zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0);
66aa66ea
TP		 1308 if (!zr->zr36057_mem) {
1309 dprintk(1,
1310 KERN_ERR
5e098b66
TP		 1311 "%s: %s() - ioremap failed\n",
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
1322 "%s: find_zr36057() - bad irq number or handler\n",
1323 ZR_DEVNAME(zr));
1324 } else if (result == -EBUSY) {
1325 dprintk(1,
1326 KERN_ERR
1327 "%s: find_zr36057() - IRQ %d busy, change your PnP config in BIOS\n",
1328 ZR_DEVNAME(zr), zr->pci_dev->irq);
1da177e4 1329 } else {
66aa66ea
TP		 1330 dprintk(1,
1331 KERN_ERR
1332 "%s: find_zr36057() - can't assign irq, error code %d\n",
1333 ZR_DEVNAME(zr), 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) {
1343 dprintk(2,
1344 KERN_INFO
1345 "%s: Changing PCI latency from %d to %d\n",
1346 ZR_DEVNAME(zr), latency, need_latency);
1347 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1348 need_latency);
1349 }
1da177e4 1350
66aa66ea
TP		 1351 zr36057_restart(zr);
1352 /* i2c */
1353 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1354 ZR_DEVNAME(zr));
1355
66aa66ea
TP		 1356 if (zoran_register_i2c(zr) < 0) {
1357 dprintk(1,
1358 KERN_ERR
1359 "%s: find_zr36057() - can't initialize i2c bus\n",
1da177e4 1360 ZR_DEVNAME(zr));
66aa66ea
TP		 1361 goto zr_free_irq;
1362 }
1da177e4 1363
0ab6e1c3
HV		 1364 zr->decoder = v4l2_i2c_new_probed_subdev(&zr->i2c_adapter,
1365 zr->card.mod_decoder, zr->card.i2c_decoder, zr->card.addrs_decoder);
1366
1367 if (zr->card.mod_encoder)
1368 zr->encoder = v4l2_i2c_new_probed_subdev(&zr->i2c_adapter,
1369 zr->card.mod_encoder, zr->card.i2c_encoder,
1370 zr->card.addrs_encoder);
1371
66aa66ea
TP		 1372 dprintk(2,
1373 KERN_INFO "%s: Initializing videocodec bus...\n",
1374 ZR_DEVNAME(zr));
1375
1376 if (zr->card.video_codec) {
1377 codec_name = codecid_to_modulename(zr->card.video_codec);
1378 if (codec_name) {
1379 result = request_module(codec_name);
1380 if (result) {
1da177e4
LT		 1381 dprintk(1,
1382 KERN_ERR
1383 "%s: failed to load modules %s: %d\n",
1384 ZR_DEVNAME(zr), codec_name, result);
1385 }
1386 }
66aa66ea
TP		 1387 }
1388 if (zr->card.video_vfe) {
1389 vfe_name = codecid_to_modulename(zr->card.video_vfe);
1390 if (vfe_name) {
1391 result = request_module(vfe_name);
1392 if (result < 0) {
1da177e4
LT		 1393 dprintk(1,
1394 KERN_ERR
1395 "%s: failed to load modules %s: %d\n",
1396 ZR_DEVNAME(zr), vfe_name, result);
1397 }
1398 }
66aa66ea 1399 }
1da177e4 1400
66aa66ea
TP		 1401 /* reset JPEG codec */
1402 jpeg_codec_sleep(zr, 1);
1403 jpeg_codec_reset(zr);
1404 /* video bus enabled */
1405 /* display codec revision */
1406 if (zr->card.video_codec != 0) {
1407 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1408 if (!master_codec)
1409 goto zr_unreg_i2c;
1410 zr->codec = videocodec_attach(master_codec);
1411 if (!zr->codec) {
1412 dprintk(1,
1413 KERN_ERR
1414 "%s: find_zr36057() - no codec found\n",
1415 ZR_DEVNAME(zr));
1416 goto zr_free_codec;
1da177e4 1417 }
66aa66ea
TP		 1418 if (zr->codec->type != zr->card.video_codec) {
1419 dprintk(1,
1420 KERN_ERR
1421 "%s: find_zr36057() - wrong codec\n",
1422 ZR_DEVNAME(zr));
1423 goto zr_detach_codec;
1da177e4 1424 }
1da177e4 1425 }
66aa66ea
TP		 1426 if (zr->card.video_vfe != 0) {
1427 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1428 if (!master_vfe)
1429 goto zr_detach_codec;
1430 zr->vfe = videocodec_attach(master_vfe);
1431 if (!zr->vfe) {
1432 dprintk(1,
1433 KERN_ERR
1434 "%s: find_zr36057() - no VFE found\n",
1435 ZR_DEVNAME(zr));
1436 goto zr_free_vfe;
1437 }
1438 if (zr->vfe->type != zr->card.video_vfe) {
1439 dprintk(1,
1440 KERN_ERR
1441 "%s: find_zr36057() = wrong VFE\n",
1442 ZR_DEVNAME(zr));
1443 goto zr_detach_vfe;
1444 }
1445 }
e491cbc8 1446
66aa66ea
TP		 1447 /* take care of Natoma chipset and a revision 1 zr36057 */
1448 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1449 zr->jpg_buffers.need_contiguous = 1;
1450 dprintk(1,
1451 KERN_INFO
1452 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1453 ZR_DEVNAME(zr));
1da177e4 1454 }
66aa66ea
TP		 1455
1456 if (zr36057_init(zr) < 0)
1457 goto zr_detach_vfe;
1458
1459 zoran_proc_init(zr);
1460
66aa66ea
TP		 1461 return 0;
1462
1463zr_detach_vfe:
1464 videocodec_detach(zr->vfe);
1465zr_free_vfe:
1466 kfree(master_vfe);
1467zr_detach_codec:
1468 videocodec_detach(zr->codec);
1469zr_free_codec:
1470 kfree(master_codec);
1471zr_unreg_i2c:
1472 zoran_unregister_i2c(zr);
1473zr_free_irq:
1474 btwrite(0, ZR36057_SPGPPCR);
1475 free_irq(zr->pci_dev->irq, zr);
1476zr_unmap:
1477 iounmap(zr->zr36057_mem);
0ab6e1c3
HV		 1478zr_unreg:
1479 v4l2_device_unregister(&zr->v4l2_dev);
66aa66ea
TP		 1480zr_free_mem:
1481 kfree(zr);
1482
1483 return -ENODEV;
1da177e4
LT		 1484}
1485
66aa66ea
TP		 1486static struct pci_driver zoran_driver = {
1487 .name = "zr36067",
1488 .id_table = zr36067_pci_tbl,
1489 .probe = zoran_probe,
1490 .remove = zoran_remove,
1491};
1492
1493static int __init zoran_init(void)
1da177e4 1494{
66aa66ea 1495 int res;
1da177e4 1496
1da177e4
LT		 1497 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1498 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1499
1da177e4
LT		 1500 /* check the parameters we have been given, adjust if necessary */
1501 if (v4l_nbufs < 2)
1502 v4l_nbufs = 2;
1503 if (v4l_nbufs > VIDEO_MAX_FRAME)
1504 v4l_nbufs = VIDEO_MAX_FRAME;
1505 /* The user specfies the in KB, we want them in byte
1506 * (and page aligned) */
1507 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1508 if (v4l_bufsize < 32768)
1509 v4l_bufsize = 32768;
1510 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1511 if (v4l_bufsize > 2048 * 1024)
1512 v4l_bufsize = 2048 * 1024;
1513 if (jpg_nbufs < 4)
1514 jpg_nbufs = 4;
1515 if (jpg_nbufs > BUZ_MAX_FRAME)
1516 jpg_nbufs = BUZ_MAX_FRAME;
1517 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1518 if (jpg_bufsize < 8192)
1519 jpg_bufsize = 8192;
1520 if (jpg_bufsize > (512 * 1024))
1521 jpg_bufsize = 512 * 1024;
1522 /* Use parameter for vidmem or try to find a video card */
1523 if (vidmem) {
1524 dprintk(1,
1525 KERN_INFO
1526 "%s: Using supplied video memory base address @ 0x%lx\n",
1527 ZORAN_NAME, vidmem);
1528 }
1529
1da177e4 1530 /* some mainboards might not do PCI-PCI data transfer well */
e355880b 1531 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1da177e4
LT		 1532 dprintk(1,
1533 KERN_WARNING
e355880b 1534 "%s: chipset does not support reliable PCI-PCI DMA\n",
1da177e4
LT		 1535 ZORAN_NAME);
1536 }
1537
66aa66ea
TP		 1538 res = pci_register_driver(&zoran_driver);
1539 if (res) {
1540 dprintk(1,
1541 KERN_ERR
1542 "%s: Unable to register ZR36057 driver\n",
1543 ZORAN_NAME);
1544 return res;
1da177e4
LT		 1545 }
1546
1547 return 0;
1548}
1549
66aa66ea 1550static void __exit zoran_exit(void)
1da177e4 1551{
66aa66ea 1552 pci_unregister_driver(&zoran_driver);
1da177e4
LT		 1553}
1554
66aa66ea
TP		 1555module_init(zoran_init);
1556module_exit(zoran_exit);
Linux kernel - Deliverables
This page took 0.533061 seconds and 5 git commands to generate.