?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.12.39
[linux/fpc-iii.git] / drivers / media / pci / zoran / zoran_card.c
blob923d59a321f8a9e150685447ecc12fc54044ca24
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] = {
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 zr->i2c_algo = zoran_i2c_bit_data_template;
712 zr->i2c_algo.data = zr;
713 strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
714 sizeof(zr->i2c_adapter.name));
715 i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
716 zr->i2c_adapter.algo_data = &zr->i2c_algo;
717 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
718 return i2c_bit_add_bus(&zr->i2c_adapter);
719 }
720
721 static void
722 zoran_unregister_i2c (struct zoran *zr)
723 {
724 i2c_del_adapter(&zr->i2c_adapter);
725 }
726
727 /* Check a zoran_params struct for correctness, insert default params */
728
729 int
730 zoran_check_jpg_settings (struct zoran *zr,
731 struct zoran_jpg_settings *settings,
732 int try)
733 {
734 int err = 0, err0 = 0;
735
736 dprintk(4,
737 KERN_DEBUG
738 "%s: %s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
739 ZR_DEVNAME(zr), __func__, settings->decimation, settings->HorDcm,
740 settings->VerDcm, settings->TmpDcm);
741 dprintk(4,
742 KERN_DEBUG
743 "%s: %s - x: %d, y: %d, w: %d, y: %d\n",
744 ZR_DEVNAME(zr), __func__, settings->img_x, settings->img_y,
745 settings->img_width, settings->img_height);
746 /* Check decimation, set default values for decimation = 1, 2, 4 */
747 switch (settings->decimation) {
748 case 1:
749
750 settings->HorDcm = 1;
751 settings->VerDcm = 1;
752 settings->TmpDcm = 1;
753 settings->field_per_buff = 2;
754 settings->img_x = 0;
755 settings->img_y = 0;
756 settings->img_width = BUZ_MAX_WIDTH;
757 settings->img_height = BUZ_MAX_HEIGHT / 2;
758 break;
759 case 2:
760
761 settings->HorDcm = 2;
762 settings->VerDcm = 1;
763 settings->TmpDcm = 2;
764 settings->field_per_buff = 1;
765 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
766 settings->img_y = 0;
767 settings->img_width =
768 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
769 settings->img_height = BUZ_MAX_HEIGHT / 2;
770 break;
771 case 4:
772
773 if (zr->card.type == DC10_new) {
774 dprintk(1,
775 KERN_DEBUG
776 "%s: %s - HDec by 4 is not supported on the DC10\n",
777 ZR_DEVNAME(zr), __func__);
778 err0++;
779 break;
780 }
781
782 settings->HorDcm = 4;
783 settings->VerDcm = 2;
784 settings->TmpDcm = 2;
785 settings->field_per_buff = 1;
786 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
787 settings->img_y = 0;
788 settings->img_width =
789 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
790 settings->img_height = BUZ_MAX_HEIGHT / 2;
791 break;
792 case 0:
793
794 /* We have to check the data the user has set */
795
796 if (settings->HorDcm != 1 && settings->HorDcm != 2 &&
797 (zr->card.type == DC10_new || settings->HorDcm != 4)) {
798 settings->HorDcm = clamp(settings->HorDcm, 1, 2);
799 err0++;
800 }
801 if (settings->VerDcm != 1 && settings->VerDcm != 2) {
802 settings->VerDcm = clamp(settings->VerDcm, 1, 2);
803 err0++;
804 }
805 if (settings->TmpDcm != 1 && settings->TmpDcm != 2) {
806 settings->TmpDcm = clamp(settings->TmpDcm, 1, 2);
807 err0++;
808 }
809 if (settings->field_per_buff != 1 &&
810 settings->field_per_buff != 2) {
811 settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
812 err0++;
813 }
814 if (settings->img_x < 0) {
815 settings->img_x = 0;
816 err0++;
817 }
818 if (settings->img_y < 0) {
819 settings->img_y = 0;
820 err0++;
821 }
822 if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
823 settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
824 err0++;
825 }
826 if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
827 settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
828 err0++;
829 }
830 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
831 settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
832 err0++;
833 }
834 if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
835 settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
836 err0++;
837 }
838 if (settings->img_width % (16 * settings->HorDcm) != 0) {
839 settings->img_width -= settings->img_width % (16 * settings->HorDcm);
840 if (settings->img_width == 0)
841 settings->img_width = 16 * settings->HorDcm;
842 err0++;
843 }
844 if (settings->img_height % (8 * settings->VerDcm) != 0) {
845 settings->img_height -= settings->img_height % (8 * settings->VerDcm);
846 if (settings->img_height == 0)
847 settings->img_height = 8 * settings->VerDcm;
848 err0++;
849 }
850
851 if (!try && err0) {
852 dprintk(1,
853 KERN_ERR
854 "%s: %s - error in params for decimation = 0\n",
855 ZR_DEVNAME(zr), __func__);
856 err++;
857 }
858 break;
859 default:
860 dprintk(1,
861 KERN_ERR
862 "%s: %s - decimation = %d, must be 0, 1, 2 or 4\n",
863 ZR_DEVNAME(zr), __func__, settings->decimation);
864 err++;
865 break;
866 }
867
868 if (settings->jpg_comp.quality > 100)
869 settings->jpg_comp.quality = 100;
870 if (settings->jpg_comp.quality < 5)
871 settings->jpg_comp.quality = 5;
872 if (settings->jpg_comp.APPn < 0)
873 settings->jpg_comp.APPn = 0;
874 if (settings->jpg_comp.APPn > 15)
875 settings->jpg_comp.APPn = 15;
876 if (settings->jpg_comp.APP_len < 0)
877 settings->jpg_comp.APP_len = 0;
878 if (settings->jpg_comp.APP_len > 60)
879 settings->jpg_comp.APP_len = 60;
880 if (settings->jpg_comp.COM_len < 0)
881 settings->jpg_comp.COM_len = 0;
882 if (settings->jpg_comp.COM_len > 60)
883 settings->jpg_comp.COM_len = 60;
884 if (err)
885 return -EINVAL;
886 return 0;
887 }
888
889 void
890 zoran_open_init_params (struct zoran *zr)
891 {
892 int i;
893
894 /* User must explicitly set a window */
895 zr->overlay_settings.is_set = 0;
896 zr->overlay_mask = NULL;
897 zr->overlay_active = ZORAN_FREE;
898
899 zr->v4l_memgrab_active = 0;
900 zr->v4l_overlay_active = 0;
901 zr->v4l_grab_frame = NO_GRAB_ACTIVE;
902 zr->v4l_grab_seq = 0;
903 zr->v4l_settings.width = 192;
904 zr->v4l_settings.height = 144;
905 zr->v4l_settings.format = &zoran_formats[7]; /* YUY2 - YUV-4:2:2 packed */
906 zr->v4l_settings.bytesperline =
907 zr->v4l_settings.width *
908 ((zr->v4l_settings.format->depth + 7) / 8);
909
910 /* DMA ring stuff for V4L */
911 zr->v4l_pend_tail = 0;
912 zr->v4l_pend_head = 0;
913 zr->v4l_sync_tail = 0;
914 zr->v4l_buffers.active = ZORAN_FREE;
915 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
916 zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
917 }
918 zr->v4l_buffers.allocated = 0;
919
920 for (i = 0; i < BUZ_MAX_FRAME; i++) {
921 zr->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
922 }
923 zr->jpg_buffers.active = ZORAN_FREE;
924 zr->jpg_buffers.allocated = 0;
925 /* Set necessary params and call zoran_check_jpg_settings to set the defaults */
926 zr->jpg_settings.decimation = 1;
927 zr->jpg_settings.jpg_comp.quality = 50; /* default compression factor 8 */
928 if (zr->card.type != BUZ)
929 zr->jpg_settings.odd_even = 1;
930 else
931 zr->jpg_settings.odd_even = 0;
932 zr->jpg_settings.jpg_comp.APPn = 0;
933 zr->jpg_settings.jpg_comp.APP_len = 0; /* No APPn marker */
934 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
935 sizeof(zr->jpg_settings.jpg_comp.APP_data));
936 zr->jpg_settings.jpg_comp.COM_len = 0; /* No COM marker */
937 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
938 sizeof(zr->jpg_settings.jpg_comp.COM_data));
939 zr->jpg_settings.jpg_comp.jpeg_markers =
940 V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT;
941 i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
942 if (i)
943 dprintk(1, KERN_ERR "%s: %s internal error\n",
944 ZR_DEVNAME(zr), __func__);
945
946 clear_interrupt_counters(zr);
947 zr->testing = 0;
948 }
949
950 static void test_interrupts (struct zoran *zr)
951 {
952 DEFINE_WAIT(wait);
953 int timeout, icr;
954
955 clear_interrupt_counters(zr);
956
957 zr->testing = 1;
958 icr = btread(ZR36057_ICR);
959 btwrite(0x78000000 | ZR36057_ICR_IntPinEn, ZR36057_ICR);
960 prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
961 timeout = schedule_timeout(HZ);
962 finish_wait(&zr->test_q, &wait);
963 btwrite(0, ZR36057_ICR);
964 btwrite(0x78000000, ZR36057_ISR);
965 zr->testing = 0;
966 dprintk(5, KERN_INFO "%s: Testing interrupts...\n", ZR_DEVNAME(zr));
967 if (timeout) {
968 dprintk(1, ": time spent: %d\n", 1 * HZ - timeout);
969 }
970 if (zr36067_debug > 1)
971 print_interrupts(zr);
972 btwrite(icr, ZR36057_ICR);
973 }
974
975 static int 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->v4l2_dev = &zr->v4l2_dev;
1054 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1055 /* It's not a mem2mem device, but you can both capture and output from
1056 one and the same device. This should really be split up into two
1057 device nodes, but that's a job for another day. */
1058 zr->video_dev->vfl_dir = VFL_DIR_M2M;
1059 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1060 if (err < 0)
1061 goto exit_free;
1062 video_set_drvdata(zr->video_dev, zr);
1063
1064 zoran_init_hardware(zr);
1065 if (zr36067_debug > 2)
1066 detect_guest_activity(zr);
1067 test_interrupts(zr);
1068 if (!pass_through) {
1069 decoder_call(zr, video, s_stream, 0);
1070 encoder_call(zr, video, s_routing, 2, 0, 0);
1071 }
1072
1073 zr->zoran_proc = NULL;
1074 zr->initialized = 1;
1075 return 0;
1076
1077 exit_free:
1078 kfree(zr->stat_com);
1079 kfree(zr->video_dev);
1080 return err;
1081 }
1082
1083 static void zoran_remove(struct pci_dev *pdev)
1084 {
1085 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1086 struct zoran *zr = to_zoran(v4l2_dev);
1087
1088 if (!zr->initialized)
1089 goto exit_free;
1090
1091 /* unregister videocodec bus */
1092 if (zr->codec) {
1093 struct videocodec_master *master = zr->codec->master_data;
1094
1095 videocodec_detach(zr->codec);
1096 kfree(master);
1097 }
1098 if (zr->vfe) {
1099 struct videocodec_master *master = zr->vfe->master_data;
1100
1101 videocodec_detach(zr->vfe);
1102 kfree(master);
1103 }
1104
1105 /* unregister i2c bus */
1106 zoran_unregister_i2c(zr);
1107 /* disable PCI bus-mastering */
1108 zoran_set_pci_master(zr, 0);
1109 /* put chip into reset */
1110 btwrite(0, ZR36057_SPGPPCR);
1111 free_irq(zr->pci_dev->irq, zr);
1112 /* unmap and free memory */
1113 kfree(zr->stat_com);
1114 zoran_proc_cleanup(zr);
1115 iounmap(zr->zr36057_mem);
1116 pci_disable_device(zr->pci_dev);
1117 video_unregister_device(zr->video_dev);
1118 exit_free:
1119 v4l2_device_unregister(&zr->v4l2_dev);
1120 kfree(zr);
1121 }
1122
1123 void
1124 zoran_vdev_release (struct video_device *vdev)
1125 {
1126 kfree(vdev);
1127 }
1128
1129 static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr,
1130 int type)
1131 {
1132 struct videocodec_master *m = NULL;
1133
1134 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1135 if (!m) {
1136 dprintk(1, KERN_ERR "%s: %s - no memory\n",
1137 ZR_DEVNAME(zr), __func__);
1138 return m;
1139 }
1140
1141 /* magic and type are unused for master struct. Makes sense only at
1142 codec structs.
1143 In the past, .type were initialized to the old V4L1 .hardware
1144 value, as VID_HARDWARE_ZR36067
1145 */
1146 m->magic = 0L;
1147 m->type = 0;
1148
1149 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1150 strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1151 m->data = zr;
1152
1153 switch (type)
1154 {
1155 case CODEC_TYPE_ZR36060:
1156 m->readreg = zr36060_read;
1157 m->writereg = zr36060_write;
1158 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1159 break;
1160 case CODEC_TYPE_ZR36050:
1161 m->readreg = zr36050_read;
1162 m->writereg = zr36050_write;
1163 m->flags |= CODEC_FLAG_JPEG;
1164 break;
1165 case CODEC_TYPE_ZR36016:
1166 m->readreg = zr36016_read;
1167 m->writereg = zr36016_write;
1168 m->flags |= CODEC_FLAG_VFE;
1169 break;
1170 }
1171
1172 return m;
1173 }
1174
1175 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1176 {
1177 struct zoran *zr = to_zoran(sd->v4l2_dev);
1178
1179 /* Bt819 needs to reset its FIFO buffer using #FRST pin and
1180 LML33 card uses GPIO(7) for that. */
1181 if (cmd == BT819_FIFO_RESET_LOW)
1182 GPIO(zr, 7, 0);
1183 else if (cmd == BT819_FIFO_RESET_HIGH)
1184 GPIO(zr, 7, 1);
1185 }
1186
1187 /*
1188 * Scan for a Buz card (actually for the PCI controller ZR36057),
1189 * request the irq and map the io memory
1190 */
1191 static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1192 {
1193 unsigned char latency, need_latency;
1194 struct zoran *zr;
1195 int result;
1196 struct videocodec_master *master_vfe = NULL;
1197 struct videocodec_master *master_codec = NULL;
1198 int card_num;
1199 char *codec_name, *vfe_name;
1200 unsigned int nr;
1201
1202
1203 nr = zoran_num++;
1204 if (nr >= BUZ_MAX) {
1205 dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n",
1206 ZORAN_NAME, BUZ_MAX);
1207 return -ENOENT;
1208 }
1209
1210 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1211 if (!zr) {
1212 dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n",
1213 ZORAN_NAME, __func__);
1214 return -ENOMEM;
1215 }
1216 zr->v4l2_dev.notify = zoran_subdev_notify;
1217 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1218 goto zr_free_mem;
1219 zr->pci_dev = pdev;
1220 zr->id = nr;
1221 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1222 spin_lock_init(&zr->spinlock);
1223 mutex_init(&zr->resource_lock);
1224 mutex_init(&zr->other_lock);
1225 if (pci_enable_device(pdev))
1226 goto zr_unreg;
1227 zr->revision = zr->pci_dev->revision;
1228
1229 dprintk(1,
1230 KERN_INFO
1231 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1232 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision,
1233 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1234 if (zr->revision >= 2) {
1235 dprintk(1,
1236 KERN_INFO
1237 "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1238 ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor,
1239 zr->pci_dev->subsystem_device);
1240 }
1241
1242 /* Use auto-detected card type? */
1243 if (card[nr] == -1) {
1244 if (zr->revision < 2) {
1245 dprintk(1,
1246 KERN_ERR
1247 "%s: No card type specified, please use the card=X module parameter\n",
1248 ZR_DEVNAME(zr));
1249 dprintk(1,
1250 KERN_ERR
1251 "%s: It is not possible to auto-detect ZR36057 based cards\n",
1252 ZR_DEVNAME(zr));
1253 goto zr_unreg;
1254 }
1255
1256 card_num = ent->driver_data;
1257 if (card_num >= NUM_CARDS) {
1258 dprintk(1,
1259 KERN_ERR
1260 "%s: Unknown card, try specifying card=X module parameter\n",
1261 ZR_DEVNAME(zr));
1262 goto zr_unreg;
1263 }
1264 dprintk(3,
1265 KERN_DEBUG
1266 "%s: %s() - card %s detected\n",
1267 ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name);
1268 } else {
1269 card_num = card[nr];
1270 if (card_num >= NUM_CARDS || card_num < 0) {
1271 dprintk(1,
1272 KERN_ERR
1273 "%s: User specified card type %d out of range (0 .. %d)\n",
1274 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
1275 goto zr_unreg;
1276 }
1277 }
1278
1279 /* even though we make this a non pointer and thus
1280 * theoretically allow for making changes to this struct
1281 * on a per-individual card basis at runtime, this is
1282 * strongly discouraged. This structure is intended to
1283 * keep general card information, no settings or anything */
1284 zr->card = zoran_cards[card_num];
1285 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1286 "%s[%u]", zr->card.name, zr->id);
1287
1288 zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0);
1289 if (!zr->zr36057_mem) {
1290 dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n",
1291 ZR_DEVNAME(zr), __func__);
1292 goto zr_unreg;
1293 }
1294
1295 result = request_irq(zr->pci_dev->irq, zoran_irq,
1296 IRQF_SHARED | IRQF_DISABLED, ZR_DEVNAME(zr), zr);
1297 if (result < 0) {
1298 if (result == -EINVAL) {
1299 dprintk(1,
1300 KERN_ERR
1301 "%s: %s - bad irq number or handler\n",
1302 ZR_DEVNAME(zr), __func__);
1303 } else if (result == -EBUSY) {
1304 dprintk(1,
1305 KERN_ERR
1306 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n",
1307 ZR_DEVNAME(zr), __func__, zr->pci_dev->irq);
1308 } else {
1309 dprintk(1,
1310 KERN_ERR
1311 "%s: %s - can't assign irq, error code %d\n",
1312 ZR_DEVNAME(zr), __func__, result);
1313 }
1314 goto zr_unmap;
1315 }
1316
1317 /* set PCI latency timer */
1318 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1319 &latency);
1320 need_latency = zr->revision > 1 ? 32 : 48;
1321 if (latency != need_latency) {
1322 dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n",
1323 ZR_DEVNAME(zr), latency, need_latency);
1324 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1325 need_latency);
1326 }
1327
1328 zr36057_restart(zr);
1329 /* i2c */
1330 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1331 ZR_DEVNAME(zr));
1332
1333 if (zoran_register_i2c(zr) < 0) {
1334 dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n",
1335 ZR_DEVNAME(zr), __func__);
1336 goto zr_free_irq;
1337 }
1338
1339 zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1340 &zr->i2c_adapter, zr->card.i2c_decoder,
1341 0, zr->card.addrs_decoder);
1342
1343 if (zr->card.i2c_encoder)
1344 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1345 &zr->i2c_adapter, zr->card.i2c_encoder,
1346 0, zr->card.addrs_encoder);
1347
1348 dprintk(2,
1349 KERN_INFO "%s: Initializing videocodec bus...\n",
1350 ZR_DEVNAME(zr));
1351
1352 if (zr->card.video_codec) {
1353 codec_name = codecid_to_modulename(zr->card.video_codec);
1354 if (codec_name) {
1355 result = request_module(codec_name);
1356 if (result) {
1357 dprintk(1,
1358 KERN_ERR
1359 "%s: failed to load modules %s: %d\n",
1360 ZR_DEVNAME(zr), codec_name, result);
1361 }
1362 }
1363 }
1364 if (zr->card.video_vfe) {
1365 vfe_name = codecid_to_modulename(zr->card.video_vfe);
1366 if (vfe_name) {
1367 result = request_module(vfe_name);
1368 if (result < 0) {
1369 dprintk(1,
1370 KERN_ERR
1371 "%s: failed to load modules %s: %d\n",
1372 ZR_DEVNAME(zr), vfe_name, result);
1373 }
1374 }
1375 }
1376
1377 /* reset JPEG codec */
1378 jpeg_codec_sleep(zr, 1);
1379 jpeg_codec_reset(zr);
1380 /* video bus enabled */
1381 /* display codec revision */
1382 if (zr->card.video_codec != 0) {
1383 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1384 if (!master_codec)
1385 goto zr_unreg_i2c;
1386 zr->codec = videocodec_attach(master_codec);
1387 if (!zr->codec) {
1388 dprintk(1, KERN_ERR "%s: %s - no codec found\n",
1389 ZR_DEVNAME(zr), __func__);
1390 goto zr_free_codec;
1391 }
1392 if (zr->codec->type != zr->card.video_codec) {
1393 dprintk(1, KERN_ERR "%s: %s - wrong codec\n",
1394 ZR_DEVNAME(zr), __func__);
1395 goto zr_detach_codec;
1396 }
1397 }
1398 if (zr->card.video_vfe != 0) {
1399 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1400 if (!master_vfe)
1401 goto zr_detach_codec;
1402 zr->vfe = videocodec_attach(master_vfe);
1403 if (!zr->vfe) {
1404 dprintk(1, KERN_ERR "%s: %s - no VFE found\n",
1405 ZR_DEVNAME(zr), __func__);
1406 goto zr_free_vfe;
1407 }
1408 if (zr->vfe->type != zr->card.video_vfe) {
1409 dprintk(1, KERN_ERR "%s: %s = wrong VFE\n",
1410 ZR_DEVNAME(zr), __func__);
1411 goto zr_detach_vfe;
1412 }
1413 }
1414
1415 /* take care of Natoma chipset and a revision 1 zr36057 */
1416 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1417 zr->jpg_buffers.need_contiguous = 1;
1418 dprintk(1, KERN_INFO
1419 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1420 ZR_DEVNAME(zr));
1421 }
1422
1423 if (zr36057_init(zr) < 0)
1424 goto zr_detach_vfe;
1425
1426 zoran_proc_init(zr);
1427
1428 return 0;
1429
1430 zr_detach_vfe:
1431 videocodec_detach(zr->vfe);
1432 zr_free_vfe:
1433 kfree(master_vfe);
1434 zr_detach_codec:
1435 videocodec_detach(zr->codec);
1436 zr_free_codec:
1437 kfree(master_codec);
1438 zr_unreg_i2c:
1439 zoran_unregister_i2c(zr);
1440 zr_free_irq:
1441 btwrite(0, ZR36057_SPGPPCR);
1442 free_irq(zr->pci_dev->irq, zr);
1443 zr_unmap:
1444 iounmap(zr->zr36057_mem);
1445 zr_unreg:
1446 v4l2_device_unregister(&zr->v4l2_dev);
1447 zr_free_mem:
1448 kfree(zr);
1449
1450 return -ENODEV;
1451 }
1452
1453 static struct pci_driver zoran_driver = {
1454 .name = "zr36067",
1455 .id_table = zr36067_pci_tbl,
1456 .probe = zoran_probe,
1457 .remove = zoran_remove,
1458 };
1459
1460 static int __init zoran_init(void)
1461 {
1462 int res;
1463
1464 printk(KERN_INFO "Zoran MJPEG board driver version %s\n",
1465 ZORAN_VERSION);
1466
1467 /* check the parameters we have been given, adjust if necessary */
1468 if (v4l_nbufs < 2)
1469 v4l_nbufs = 2;
1470 if (v4l_nbufs > VIDEO_MAX_FRAME)
1471 v4l_nbufs = VIDEO_MAX_FRAME;
1472 /* The user specfies the in KB, we want them in byte
1473 * (and page aligned) */
1474 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1475 if (v4l_bufsize < 32768)
1476 v4l_bufsize = 32768;
1477 /* 2 MB is arbitrary but sufficient for the maximum possible images */
1478 if (v4l_bufsize > 2048 * 1024)
1479 v4l_bufsize = 2048 * 1024;
1480 if (jpg_nbufs < 4)
1481 jpg_nbufs = 4;
1482 if (jpg_nbufs > BUZ_MAX_FRAME)
1483 jpg_nbufs = BUZ_MAX_FRAME;
1484 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1485 if (jpg_bufsize < 8192)
1486 jpg_bufsize = 8192;
1487 if (jpg_bufsize > (512 * 1024))
1488 jpg_bufsize = 512 * 1024;
1489 /* Use parameter for vidmem or try to find a video card */
1490 if (vidmem) {
1491 dprintk(1,
1492 KERN_INFO
1493 "%s: Using supplied video memory base address @ 0x%lx\n",
1494 ZORAN_NAME, vidmem);
1495 }
1496
1497 /* some mainboards might not do PCI-PCI data transfer well */
1498 if (pci_pci_problems & (PCIPCI_FAIL|PCIAGP_FAIL|PCIPCI_ALIMAGIK)) {
1499 dprintk(1,
1500 KERN_WARNING
1501 "%s: chipset does not support reliable PCI-PCI DMA\n",
1502 ZORAN_NAME);
1503 }
1504
1505 res = pci_register_driver(&zoran_driver);
1506 if (res) {
1507 dprintk(1,
1508 KERN_ERR
1509 "%s: Unable to register ZR36057 driver\n",
1510 ZORAN_NAME);
1511 return res;
1512 }
1513
1514 return 0;
1515 }
1516
1517 static void __exit zoran_exit(void)
1518 {
1519 pci_unregister_driver(&zoran_driver);
1520 }
1521
1522 module_init(zoran_init);
1523 module_exit(zoran_exit);
Linux with added FPC-III support