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