]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/media/video/zoran/zoran_card.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB: cleanup redundant tests on unsigned
[mirror_ubuntu-artful-kernel.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 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
c61402ba
TP		 761 "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
762 ZR_DEVNAME(zr), __func__, settings->decimation, settings->HorDcm,
1da177e4
LT		 763 settings->VerDcm, settings->TmpDcm);
764 dprintk(4,
765 KERN_DEBUG
c61402ba
TP		 766 "%s: %s - x: %d, y: %d, w: %d, y: %d\n",
767 ZR_DEVNAME(zr), __func__, settings->img_x, settings->img_y,
1da177e4
LT		 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
c61402ba
TP		 799 "%s: %s - HDec by 4 is not supported on the DC10\n",
800 ZR_DEVNAME(zr), __func__);
1da177e4
LT		 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
c61402ba
TP		 877 "%s: %s - error in params for decimation = 0\n",
878 ZR_DEVNAME(zr), __func__);
1da177e4
LT		 879 err++;
880 }
881 break;
882 default:
883 dprintk(1,
884 KERN_ERR
c61402ba
TP		 885 "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n",
886 ZR_DEVNAME(zr), __func__, settings->decimation);
1da177e4
LT		 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 965 if (i)
c61402ba
TP		 966 dprintk(1, KERN_ERR "%s: %s internal error\n",
967 ZR_DEVNAME(zr), __func__);
1da177e4
LT		 968
969 clear_interrupt_counters(zr);
970 zr->testing = 0;
971}
972
973static void __devinit
974test_interrupts (struct zoran *zr)
975{
976 DEFINE_WAIT(wait);
977 int timeout, icr;
978
979 clear_interrupt_counters(zr);
980
981 zr->testing = 1;
982 icr = btread(ZR36057_ICR);
983 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
984 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
985 timeout = schedule_timeout(HZ);
986 finish_wait(&zr->test_q, &wait);
987 btwrite(0, ZR36057_ICR);
988 btwrite(0x78000000, ZR36057_ISR);
989 zr->testing = 0;
990 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
991 if (timeout) {
992 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
993 }
18b548ca 994 if (zr36067_debug > 1)
1da177e4
LT		 995 print_interrupts(zr);
996 btwrite(icr, ZR36057_ICR);
997}
998
999static int __devinit
1000zr36057_init (struct zoran *zr)
1001{
daf72f40 1002 int j, err;
1da177e4
LT		 1003
1004 dprintk(1,
1005 KERN_INFO
c61402ba
TP		 1006 "%s: %s - initializing card[%d], zr=%p\n",
1007 ZR_DEVNAME(zr), __func__, zr->id, zr);
1da177e4
LT		 1008
1009 /* default setup of all parameters which will persist between opens */
1010 zr->user = 0;
1011
1012 init_waitqueue_head(&zr->v4l_capq);
1013 init_waitqueue_head(&zr->jpg_capq);
1014 init_waitqueue_head(&zr->test_q);
1015 zr->jpg_buffers.allocated = 0;
1016 zr->v4l_buffers.allocated = 0;
1017
7f6adeaf
HV		 1018 zr->vbuf_base = (void *) vidmem;
1019 zr->vbuf_width = 0;
1020 zr->vbuf_height = 0;
1021 zr->vbuf_depth = 0;
1022 zr->vbuf_bytesperline = 0;
1da177e4
LT		 1023
1024 /* Avoid nonsense settings from user for default input/norm */
7f6adeaf
HV		 1025 if (default_norm < 0 && default_norm > 2)
1026 default_norm = 0;
1027 if (default_norm == 0) {
107063c6
HV		 1028 zr->norm = V4L2_STD_PAL;
1029 zr->timing = zr->card.tvn[0];
7f6adeaf 1030 } else if (default_norm == 1) {
107063c6
HV		 1031 zr->norm = V4L2_STD_NTSC;
1032 zr->timing = zr->card.tvn[1];
1033 } else {
1034 zr->norm = V4L2_STD_SECAM;
1035 zr->timing = zr->card.tvn[2];
1036 }
1037 if (zr->timing == NULL) {
1da177e4
LT		 1038 dprintk(1,
1039 KERN_WARNING
c61402ba
TP		 1040 "%s: %s - default TV standard not supported by hardware. PAL will be used.\n",
1041 ZR_DEVNAME(zr), __func__);
107063c6
HV		 1042 zr->norm = V4L2_STD_PAL;
1043 zr->timing = zr->card.tvn[0];
1da177e4
LT		 1044 }
1045
60e3cac4
TP		 1046 if (default_input > zr->card.inputs-1) {
1047 dprintk(1,
1048 KERN_WARNING
1049 "%s: default_input value %d out of range (0-%d)\n",
1050 ZR_DEVNAME(zr), default_input, zr->card.inputs-1);
1051 default_input = 0;
1052 }
1053 zr->input = default_input;
1da177e4 1054
1da177e4
LT		 1055 /* default setup (will be repeated at every open) */
1056 zoran_open_init_params(zr);
1057
1058 /* allocate memory *before* doing anything to the hardware
1059 * in case allocation fails */
daf72f40
JD		 1060 zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
1061 zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
1062 if (!zr->stat_com || !zr->video_dev) {
1da177e4
LT		 1063 dprintk(1,
1064 KERN_ERR
c61402ba
TP		 1065 "%s: %s - kmalloc (STAT_COM) failed\n",
1066 ZR_DEVNAME(zr), __func__);
daf72f40
JD		 1067 err = -ENOMEM;
1068 goto exit_free;
1da177e4 1069 }
1da177e4 1070 for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
9c169df8 1071 zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1da177e4
LT		 1072 }
1073
1074 /*
1075 * Now add the template and register the device unit.
1076 */
1da177e4 1077 memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
aff88bca 1078 zr->video_dev->parent = &zr->pci_dev->dev;
1da177e4 1079 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
60e3cac4 1080 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
daf72f40 1081 if (err < 0)
66aa66ea 1082 goto exit_free;
601139e0 1083 video_set_drvdata(zr->video_dev, zr);
1da177e4
LT		 1084
1085 zoran_init_hardware(zr);
18b548ca 1086 if (zr36067_debug > 2)
1da177e4
LT		 1087 detect_guest_activity(zr);
1088 test_interrupts(zr);
1089 if (!pass_through) {
0ab6e1c3 1090 decoder_call(zr, video, s_stream, 0);
5325b427 1091 encoder_call(zr, video, s_routing, 2, 0, 0);
1da177e4
LT		 1092 }
1093
1094 zr->zoran_proc = NULL;
1095 zr->initialized = 1;
1096 return 0;
daf72f40 1097
daf72f40
JD		 1098exit_free:
1099 kfree(zr->stat_com);
1100 kfree(zr->video_dev);
1101 return err;
1da177e4
LT		 1102}
1103
66aa66ea 1104static void __devexit zoran_remove(struct pci_dev *pdev)
1da177e4 1105{
0ab6e1c3
HV		 1106 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1107 struct zoran *zr = to_zoran(v4l2_dev);
66aa66ea 1108
1da177e4 1109 if (!zr->initialized)
85b9b8a4 1110 goto exit_free;
66aa66ea 1111
1da177e4
LT		 1112 /* unregister videocodec bus */
1113 if (zr->codec) {
1114 struct videocodec_master *master = zr->codec->master_data;
2ea75330 1115
1da177e4 1116 videocodec_detach(zr->codec);
2ea75330 1117 kfree(master);
1da177e4
LT		 1118 }
1119 if (zr->vfe) {
1120 struct videocodec_master *master = zr->vfe->master_data;
2ea75330 1121
1da177e4 1122 videocodec_detach(zr->vfe);
2ea75330 1123 kfree(master);
1da177e4
LT		 1124 }
1125
1126 /* unregister i2c bus */
1127 zoran_unregister_i2c(zr);
1128 /* disable PCI bus-mastering */
1129 zoran_set_pci_master(zr, 0);
1130 /* put chip into reset */
1131 btwrite(0, ZR36057_SPGPPCR);
1132 free_irq(zr->pci_dev->irq, zr);
1133 /* unmap and free memory */
daf72f40 1134 kfree(zr->stat_com);
1da177e4
LT		 1135 zoran_proc_cleanup(zr);
1136 iounmap(zr->zr36057_mem);
1137 pci_disable_device(zr->pci_dev);
1138 video_unregister_device(zr->video_dev);
85b9b8a4 1139exit_free:
0ab6e1c3 1140 v4l2_device_unregister(&zr->v4l2_dev);
85b9b8a4 1141 kfree(zr);
1da177e4
LT		 1142}
1143
1144void
1145zoran_vdev_release (struct video_device *vdev)
1146{
1147 kfree(vdev);
1148}
1149
1150static struct videocodec_master * __devinit
1151zoran_setup_videocodec (struct zoran *zr,
1152 int type)
1153{
1154 struct videocodec_master *m = NULL;
1155
1156 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1157 if (!m) {
c61402ba
TP		 1158 dprintk(1, KERN_ERR "%s: %s - no memory\n",
1159 ZR_DEVNAME(zr), __func__);
1da177e4
LT		 1160 return m;
1161 }
1162
22c4a4e9
MCC		 1163 /* magic and type are unused for master struct. Makes sense only at
1164 codec structs.
1165 In the past, .type were initialized to the old V4L1 .hardware
1166 value, as VID_HARDWARE_ZR36067
1167 */
1168 m->magic = 0L;
1169 m->type = 0;
1170
1da177e4
LT		 1171 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1172 strncpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1173 m->data = zr;
1174
1175 switch (type)
1176 {
1177 case CODEC_TYPE_ZR36060:
1178 m->readreg = zr36060_read;
1179 m->writereg = zr36060_write;
1180 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1181 break;
1182 case CODEC_TYPE_ZR36050:
1183 m->readreg = zr36050_read;
1184 m->writereg = zr36050_write;
1185 m->flags |= CODEC_FLAG_JPEG;
1186 break;
1187 case CODEC_TYPE_ZR36016:
1188 m->readreg = zr36016_read;
1189 m->writereg = zr36016_write;
1190 m->flags |= CODEC_FLAG_VFE;
1191 break;
1192 }
1193
1194 return m;
1195}
1196
33470423 1197static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1cd3c0fa
HV		 1198{
1199 struct zoran *zr = to_zoran(sd->v4l2_dev);
1200
1201 /* Bt819 needs to reset its FIFO buffer using #FRST pin and
1202 LML33 card uses GPIO(7) for that. */
1203 if (cmd == BT819_FIFO_RESET_LOW)
1204 GPIO(zr, 7, 0);
1205 else if (cmd == BT819_FIFO_RESET_HIGH)
1206 GPIO(zr, 7, 1);
1cd3c0fa
HV		 1207}
1208
1da177e4 1209/*
c84e6036 1210 * Scan for a Buz card (actually for the PCI controller ZR36057),
1da177e4
LT		 1211 * request the irq and map the io memory
1212 */
66aa66ea
TP		 1213static int __devinit zoran_probe(struct pci_dev *pdev,
1214 const struct pci_device_id *ent)
1da177e4
LT		 1215{
1216 unsigned char latency, need_latency;
1217 struct zoran *zr;
1da177e4
LT		 1218 int result;
1219 struct videocodec_master *master_vfe = NULL;
1220 struct videocodec_master *master_codec = NULL;
1221 int card_num;
0ab6e1c3 1222 char *codec_name, *vfe_name;
66aa66ea 1223 unsigned int nr;
1da177e4 1224
1da177e4 1225
601139e0 1226 nr = zoran_num++;
66aa66ea 1227 if (nr >= BUZ_MAX) {
c61402ba 1228 dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n",
66aa66ea
TP		 1229 ZORAN_NAME, BUZ_MAX);
1230 return -ENOENT;
1231 }
1da177e4 1232
66aa66ea
TP		 1233 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1234 if (!zr) {
c61402ba
TP		 1235 dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n",
1236 ZORAN_NAME, __func__);
66aa66ea
TP		 1237 return -ENOMEM;
1238 }
1cd3c0fa 1239 zr->v4l2_dev.notify = zoran_subdev_notify;
0ab6e1c3
HV		 1240 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1241 goto zr_free_mem;
66aa66ea
TP		 1242 zr->pci_dev = pdev;
1243 zr->id = nr;
1244 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1245 spin_lock_init(&zr->spinlock);
1246 mutex_init(&zr->resource_lock);
1247 if (pci_enable_device(pdev))
0ab6e1c3 1248 goto zr_unreg;
66aa66ea 1249 pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION, &zr->revision);
17faeb20
TP		 1250
1251 dprintk(1,
1252 KERN_INFO
5e098b66 1253 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
17faeb20 1254 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision,
5e098b66 1255 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
17faeb20 1256 if (zr->revision >= 2) {
66aa66ea
TP		 1257 dprintk(1,
1258 KERN_INFO
17faeb20
TP		 1259 "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1260 ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor,
1261 zr->pci_dev->subsystem_device);
1262 }
1da177e4 1263
17faeb20
TP		 1264 /* Use auto-detected card type? */
1265 if (card[nr] == -1) {
1266 if (zr->revision < 2) {
1da177e4
LT		 1267 dprintk(1,
1268 KERN_ERR
17faeb20
TP		 1269 "%s: No card type specified, please use the card=X module parameter\n",
1270 ZR_DEVNAME(zr));
1271 dprintk(1,
1272 KERN_ERR
1273 "%s: It is not possible to auto-detect ZR36057 based cards\n",
1da177e4 1274 ZR_DEVNAME(zr));
0ab6e1c3 1275 goto zr_unreg;
1da177e4
LT		 1276 }
1277
17faeb20
TP		 1278 card_num = ent->driver_data;
1279 if (card_num >= NUM_CARDS) {
1280 dprintk(1,
1281 KERN_ERR
1282 "%s: Unknown card, try specifying card=X module parameter\n",
66aa66ea 1283 ZR_DEVNAME(zr));
0ab6e1c3 1284 goto zr_unreg;
17faeb20
TP		 1285 }
1286 dprintk(3,
1287 KERN_DEBUG
1288 "%s: %s() - card %s detected\n",
1289 ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name);
1290 } else {
1291 card_num = card[nr];
1292 if (card_num >= NUM_CARDS || card_num < 0) {
1293 dprintk(1,
1294 KERN_ERR
1295 "%s: User specified card type %d out of range (0 .. %d)\n",
1296 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
0ab6e1c3 1297 goto zr_unreg;
1da177e4 1298 }
66aa66ea 1299 }
1da177e4 1300
66aa66ea
TP		 1301 /* even though we make this a non pointer and thus
1302 * theoretically allow for making changes to this struct
1303 * on a per-individual card basis at runtime, this is
1304 * strongly discouraged. This structure is intended to
1305 * keep general card information, no settings or anything */
1306 zr->card = zoran_cards[card_num];
1307 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1308 "%s[%u]", zr->card.name, zr->id);
1309
5e098b66 1310 zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0);
66aa66ea 1311 if (!zr->zr36057_mem) {
c61402ba 1312 dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n",
5e098b66 1313 ZR_DEVNAME(zr), __func__);
0ab6e1c3 1314 goto zr_unreg;
66aa66ea 1315 }
1da177e4 1316
66aa66ea
TP		 1317 result = request_irq(zr->pci_dev->irq, zoran_irq,
1318 IRQF_SHARED | IRQF_DISABLED, ZR_DEVNAME(zr), zr);
1319 if (result < 0) {
1320 if (result == -EINVAL) {
1321 dprintk(1,
1322 KERN_ERR
c61402ba
TP		 1323 "%s: %s - bad irq number or handler\n",
1324 ZR_DEVNAME(zr), __func__);
66aa66ea
TP		 1325 } else if (result == -EBUSY) {
1326 dprintk(1,
1327 KERN_ERR
c61402ba
TP		 1328 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n",
1329 ZR_DEVNAME(zr), __func__, zr->pci_dev->irq);
1da177e4 1330 } else {
66aa66ea
TP		 1331 dprintk(1,
1332 KERN_ERR
c61402ba
TP		 1333 "%s: %s - can't assign irq, error code %d\n",
1334 ZR_DEVNAME(zr), __func__, result);
1da177e4 1335 }
66aa66ea
TP		 1336 goto zr_unmap;
1337 }
1da177e4 1338
66aa66ea
TP		 1339 /* set PCI latency timer */
1340 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1341 &latency);
1342 need_latency = zr->revision > 1 ? 32 : 48;
1343 if (latency != need_latency) {
c61402ba 1344 dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n",
66aa66ea
TP		 1345 ZR_DEVNAME(zr), latency, need_latency);
1346 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1347 need_latency);
1348 }
1da177e4 1349
66aa66ea
TP		 1350 zr36057_restart(zr);
1351 /* i2c */
1352 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1353 ZR_DEVNAME(zr));
1354
66aa66ea 1355 if (zoran_register_i2c(zr) < 0) {
c61402ba
TP		 1356 dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n",
1357 ZR_DEVNAME(zr), __func__);
66aa66ea
TP		 1358 goto zr_free_irq;
1359 }
1da177e4 1360
e6574f2f
HV		 1361 zr->decoder = v4l2_i2c_new_probed_subdev(&zr->v4l2_dev,
1362 &zr->i2c_adapter, zr->card.mod_decoder, zr->card.i2c_decoder,
1363 zr->card.addrs_decoder);
0ab6e1c3
HV		 1364
1365 if (zr->card.mod_encoder)
e6574f2f
HV		 1366 zr->encoder = v4l2_i2c_new_probed_subdev(&zr->v4l2_dev,
1367 &zr->i2c_adapter,
0ab6e1c3
HV		 1368 zr->card.mod_encoder, zr->card.i2c_encoder,
1369 zr->card.addrs_encoder);
1370
66aa66ea
TP		 1371 dprintk(2,
1372 KERN_INFO "%s: Initializing videocodec bus...\n",
1373 ZR_DEVNAME(zr));
1374
1375 if (zr->card.video_codec) {
1376 codec_name = codecid_to_modulename(zr->card.video_codec);
1377 if (codec_name) {
1378 result = request_module(codec_name);
1379 if (result) {
1da177e4
LT		 1380 dprintk(1,
1381 KERN_ERR
1382 "%s: failed to load modules %s: %d\n",
1383 ZR_DEVNAME(zr), codec_name, result);
1384 }
1385 }
66aa66ea
TP		 1386 }
1387 if (zr->card.video_vfe) {
1388 vfe_name = codecid_to_modulename(zr->card.video_vfe);
1389 if (vfe_name) {
1390 result = request_module(vfe_name);
1391 if (result < 0) {
1da177e4
LT		 1392 dprintk(1,
1393 KERN_ERR
1394 "%s: failed to load modules %s: %d\n",
1395 ZR_DEVNAME(zr), vfe_name, result);
1396 }
1397 }
66aa66ea 1398 }
1da177e4 1399
66aa66ea
TP		 1400 /* reset JPEG codec */
1401 jpeg_codec_sleep(zr, 1);
1402 jpeg_codec_reset(zr);
1403 /* video bus enabled */
1404 /* display codec revision */
1405 if (zr->card.video_codec != 0) {
1406 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1407 if (!master_codec)
1408 goto zr_unreg_i2c;
1409 zr->codec = videocodec_attach(master_codec);
1410 if (!zr->codec) {
c61402ba
TP		 1411 dprintk(1, KERN_ERR "%s: %s - no codec found\n",
1412 ZR_DEVNAME(zr), __func__);
66aa66ea 1413 goto zr_free_codec;
1da177e4 1414 }
66aa66ea 1415 if (zr->codec->type != zr->card.video_codec) {
c61402ba
TP		 1416 dprintk(1, KERN_ERR "%s: %s - wrong codec\n",
1417 ZR_DEVNAME(zr), __func__);
66aa66ea 1418 goto zr_detach_codec;
1da177e4 1419 }
1da177e4 1420 }
66aa66ea
TP		 1421 if (zr->card.video_vfe != 0) {
1422 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1423 if (!master_vfe)
1424 goto zr_detach_codec;
1425 zr->vfe = videocodec_attach(master_vfe);
1426 if (!zr->vfe) {
c61402ba
TP		 1427 dprintk(1, KERN_ERR "%s: %s - no VFE found\n",
1428 ZR_DEVNAME(zr), __func__);
66aa66ea
TP		 1429 goto zr_free_vfe;
1430 }
1431 if (zr->vfe->type != zr->card.video_vfe) {
c61402ba
TP		 1432 dprintk(1, KERN_ERR "%s: %s = wrong VFE\n",
1433 ZR_DEVNAME(zr), __func__);
66aa66ea
TP		 1434 goto zr_detach_vfe;
1435 }
1436 }
e491cbc8 1437
66aa66ea
TP		 1438 /* take care of Natoma chipset and a revision 1 zr36057 */
1439 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1440 zr->jpg_buffers.need_contiguous = 1;
c61402ba 1441 dprintk(1, KERN_INFO
66aa66ea
TP		 1442 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1443 ZR_DEVNAME(zr));
1da177e4 1444 }
66aa66ea
TP		 1445
1446 if (zr36057_init(zr) < 0)
1447 goto zr_detach_vfe;
1448
1449 zoran_proc_init(zr);
1450
66aa66ea
TP		 1451 return 0;
1452
1453zr_detach_vfe:
1454 videocodec_detach(zr->vfe);
1455zr_free_vfe:
1456 kfree(master_vfe);
1457zr_detach_codec:
1458 videocodec_detach(zr->codec);
1459zr_free_codec:
1460 kfree(master_codec);
1461zr_unreg_i2c:
1462 zoran_unregister_i2c(zr);
1463zr_free_irq:
1464 btwrite(0, ZR36057_SPGPPCR);
1465 free_irq(zr->pci_dev->irq, zr);
1466zr_unmap:
1467 iounmap(zr->zr36057_mem);
0ab6e1c3
HV		 1468zr_unreg:
1469 v4l2_device_unregister(&zr->v4l2_dev);
66aa66ea
TP		 1470zr_free_mem:
1471 kfree(zr);
1472
1473 return -ENODEV;
1da177e4
LT		 1474}
1475
66aa66ea
TP		 1476static struct pci_driver zoran_driver = {
1477 .name = "zr36067",
1478 .id_table = zr36067_pci_tbl,
1479 .probe = zoran_probe,
1480 .remove = zoran_remove,
1481};
1482
1483static int __init zoran_init(void)
1da177e4 1484{
66aa66ea 1485 int res;
1da177e4 1486
1da177e4
LT		 1487 printk(KERN_INFO "Zoran MJPEG board driver version %d.%d.%d\n",
1488 MAJOR_VERSION, MINOR_VERSION, RELEASE_VERSION);
1489
1da177e4
LT		 1490 /* check the parameters we have been given, adjust if necessary */
1491 if (v4l_nbufs < 2)
1492 v4l_nbufs = 2;
1493 if (v4l_nbufs > VIDEO_MAX_FRAME)
1494 v4l_nbufs = VIDEO_MAX_FRAME;
1495 /* The user specfies the in KB, we want them in byte
1496 * (and page aligned) */
1497 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1498 if (v4l_bufsize < 32768)
1499 v4l_bufsize = 32768;
1500 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1501 if (v4l_bufsize > 2048 * 1024)
1502 v4l_bufsize = 2048 * 1024;
1503 if (jpg_nbufs < 4)
1504 jpg_nbufs = 4;
1505 if (jpg_nbufs > BUZ_MAX_FRAME)
1506 jpg_nbufs = BUZ_MAX_FRAME;
1507 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1508 if (jpg_bufsize < 8192)
1509 jpg_bufsize = 8192;
1510 if (jpg_bufsize > (512 * 1024))
1511 jpg_bufsize = 512 * 1024;
1512 /* Use parameter for vidmem or try to find a video card */
1513 if (vidmem) {
1514 dprintk(1,
1515 KERN_INFO
1516 "%s: Using supplied video memory base address @ 0x%lx\n",
1517 ZORAN_NAME, vidmem);
1518 }
1519
1da177e4 1520 /* some mainboards might not do PCI-PCI data transfer well */
e355880b 1521 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1da177e4
LT		 1522 dprintk(1,
1523 KERN_WARNING
e355880b 1524 "%s: chipset does not support reliable PCI-PCI DMA\n",
1da177e4
LT		 1525 ZORAN_NAME);
1526 }
1527
66aa66ea
TP		 1528 res = pci_register_driver(&zoran_driver);
1529 if (res) {
1530 dprintk(1,
1531 KERN_ERR
1532 "%s: Unable to register ZR36057 driver\n",
1533 ZORAN_NAME);
1534 return res;
1da177e4
LT		 1535 }
1536
1537 return 0;
1538}
1539
66aa66ea 1540static void __exit zoran_exit(void)
1da177e4 1541{
66aa66ea 1542 pci_unregister_driver(&zoran_driver);
1da177e4
LT		 1543}
1544
66aa66ea
TP		 1545module_init(zoran_init);
1546module_exit(zoran_exit);
Ubuntu Artful kernel mirror