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