?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sh_eth: R8A7740 supports packet shecksumming
[linux/fpc-iii.git] / drivers / media / pci / zoran / zoran_card.c
blob9d2697f5b455d261b0bdc9447cf13e764a398e14
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/i2c/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 *zr->video_dev = zoran_template;
1053 zr->video_dev->v4l2_dev = &zr->v4l2_dev;
1054 zr->video_dev->lock = &zr->lock;
1055 strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
1056 /* It's not a mem2mem device, but you can both capture and output from
1057 one and the same device. This should really be split up into two
1058 device nodes, but that's a job for another day. */
1059 zr->video_dev->vfl_dir = VFL_DIR_M2M;
1060 err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr[zr->id]);
1061 if (err < 0)
1062 goto exit_free;
1063 video_set_drvdata(zr->video_dev, zr);
1064
1065 zoran_init_hardware(zr);
1066 if (zr36067_debug > 2)
1067 detect_guest_activity(zr);
1068 test_interrupts(zr);
1069 if (!pass_through) {
1070 decoder_call(zr, video, s_stream, 0);
1071 encoder_call(zr, video, s_routing, 2, 0, 0);
1072 }
1073
1074 zr->zoran_proc = NULL;
1075 zr->initialized = 1;
1076 return 0;
1077
1078 exit_free:
1079 kfree(zr->stat_com);
1080 kfree(zr->video_dev);
1081 return err;
1082 }
1083
1084 static void zoran_remove(struct pci_dev *pdev)
1085 {
1086 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1087 struct zoran *zr = to_zoran(v4l2_dev);
1088
1089 if (!zr->initialized)
1090 goto exit_free;
1091
1092 /* unregister videocodec bus */
1093 if (zr->codec) {
1094 struct videocodec_master *master = zr->codec->master_data;
1095
1096 videocodec_detach(zr->codec);
1097 kfree(master);
1098 }
1099 if (zr->vfe) {
1100 struct videocodec_master *master = zr->vfe->master_data;
1101
1102 videocodec_detach(zr->vfe);
1103 kfree(master);
1104 }
1105
1106 /* unregister i2c bus */
1107 zoran_unregister_i2c(zr);
1108 /* disable PCI bus-mastering */
1109 zoran_set_pci_master(zr, 0);
1110 /* put chip into reset */
1111 btwrite(0, ZR36057_SPGPPCR);
1112 free_irq(zr->pci_dev->irq, zr);
1113 /* unmap and free memory */
1114 kfree(zr->stat_com);
1115 zoran_proc_cleanup(zr);
1116 iounmap(zr->zr36057_mem);
1117 pci_disable_device(zr->pci_dev);
1118 video_unregister_device(zr->video_dev);
1119 exit_free:
1120 v4l2_ctrl_handler_free(&zr->hdl);
1121 v4l2_device_unregister(&zr->v4l2_dev);
1122 kfree(zr);
1123 }
1124
1125 void
1126 zoran_vdev_release (struct video_device *vdev)
1127 {
1128 kfree(vdev);
1129 }
1130
1131 static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr,
1132 int type)
1133 {
1134 struct videocodec_master *m = NULL;
1135
1136 m = kmalloc(sizeof(struct videocodec_master), GFP_KERNEL);
1137 if (!m) {
1138 dprintk(1, KERN_ERR "%s: %s - no memory\n",
1139 ZR_DEVNAME(zr), __func__);
1140 return m;
1141 }
1142
1143 /* magic and type are unused for master struct. Makes sense only at
1144 codec structs.
1145 In the past, .type were initialized to the old V4L1 .hardware
1146 value, as VID_HARDWARE_ZR36067
1147 */
1148 m->magic = 0L;
1149 m->type = 0;
1150
1151 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1152 strlcpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1153 m->data = zr;
1154
1155 switch (type)
1156 {
1157 case CODEC_TYPE_ZR36060:
1158 m->readreg = zr36060_read;
1159 m->writereg = zr36060_write;
1160 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1161 break;
1162 case CODEC_TYPE_ZR36050:
1163 m->readreg = zr36050_read;
1164 m->writereg = zr36050_write;
1165 m->flags |= CODEC_FLAG_JPEG;
1166 break;
1167 case CODEC_TYPE_ZR36016:
1168 m->readreg = zr36016_read;
1169 m->writereg = zr36016_write;
1170 m->flags |= CODEC_FLAG_VFE;
1171 break;
1172 }
1173
1174 return m;
1175 }
1176
1177 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1178 {
1179 struct zoran *zr = to_zoran(sd->v4l2_dev);
1180
1181 /* Bt819 needs to reset its FIFO buffer using #FRST pin and
1182 LML33 card uses GPIO(7) for that. */
1183 if (cmd == BT819_FIFO_RESET_LOW)
1184 GPIO(zr, 7, 0);
1185 else if (cmd == BT819_FIFO_RESET_HIGH)
1186 GPIO(zr, 7, 1);
1187 }
1188
1189 /*
1190 * Scan for a Buz card (actually for the PCI controller ZR36057),
1191 * request the irq and map the io memory
1192 */
1193 static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1194 {
1195 unsigned char latency, need_latency;
1196 struct zoran *zr;
1197 int result;
1198 struct videocodec_master *master_vfe = NULL;
1199 struct videocodec_master *master_codec = NULL;
1200 int card_num;
1201 char *codec_name, *vfe_name;
1202 unsigned int nr;
1203
1204
1205 nr = zoran_num++;
1206 if (nr >= BUZ_MAX) {
1207 dprintk(1, KERN_ERR "%s: driver limited to %d card(s) maximum\n",
1208 ZORAN_NAME, BUZ_MAX);
1209 return -ENOENT;
1210 }
1211
1212 zr = kzalloc(sizeof(struct zoran), GFP_KERNEL);
1213 if (!zr) {
1214 dprintk(1, KERN_ERR "%s: %s - kzalloc failed\n",
1215 ZORAN_NAME, __func__);
1216 return -ENOMEM;
1217 }
1218 zr->v4l2_dev.notify = zoran_subdev_notify;
1219 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1220 goto zr_free_mem;
1221 zr->pci_dev = pdev;
1222 zr->id = nr;
1223 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1224 if (v4l2_ctrl_handler_init(&zr->hdl, 10))
1225 goto zr_unreg;
1226 zr->v4l2_dev.ctrl_handler = &zr->hdl;
1227 spin_lock_init(&zr->spinlock);
1228 mutex_init(&zr->lock);
1229 if (pci_enable_device(pdev))
1230 goto zr_unreg;
1231 zr->revision = zr->pci_dev->revision;
1232
1233 dprintk(1,
1234 KERN_INFO
1235 "%s: Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1236 ZR_DEVNAME(zr), zr->revision < 2 ? '5' : '6', zr->revision,
1237 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1238 if (zr->revision >= 2) {
1239 dprintk(1,
1240 KERN_INFO
1241 "%s: Subsystem vendor=0x%04x id=0x%04x\n",
1242 ZR_DEVNAME(zr), zr->pci_dev->subsystem_vendor,
1243 zr->pci_dev->subsystem_device);
1244 }
1245
1246 /* Use auto-detected card type? */
1247 if (card[nr] == -1) {
1248 if (zr->revision < 2) {
1249 dprintk(1,
1250 KERN_ERR
1251 "%s: No card type specified, please use the card=X module parameter\n",
1252 ZR_DEVNAME(zr));
1253 dprintk(1,
1254 KERN_ERR
1255 "%s: It is not possible to auto-detect ZR36057 based cards\n",
1256 ZR_DEVNAME(zr));
1257 goto zr_unreg;
1258 }
1259
1260 card_num = ent->driver_data;
1261 if (card_num >= NUM_CARDS) {
1262 dprintk(1,
1263 KERN_ERR
1264 "%s: Unknown card, try specifying card=X module parameter\n",
1265 ZR_DEVNAME(zr));
1266 goto zr_unreg;
1267 }
1268 dprintk(3,
1269 KERN_DEBUG
1270 "%s: %s() - card %s detected\n",
1271 ZR_DEVNAME(zr), __func__, zoran_cards[card_num].name);
1272 } else {
1273 card_num = card[nr];
1274 if (card_num >= NUM_CARDS || card_num < 0) {
1275 dprintk(1,
1276 KERN_ERR
1277 "%s: User specified card type %d out of range (0 .. %d)\n",
1278 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
1279 goto zr_unreg;
1280 }
1281 }
1282
1283 /* even though we make this a non pointer and thus
1284 * theoretically allow for making changes to this struct
1285 * on a per-individual card basis at runtime, this is
1286 * strongly discouraged. This structure is intended to
1287 * keep general card information, no settings or anything */
1288 zr->card = zoran_cards[card_num];
1289 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)),
1290 "%s[%u]", zr->card.name, zr->id);
1291
1292 zr->zr36057_mem = pci_ioremap_bar(zr->pci_dev, 0);
1293 if (!zr->zr36057_mem) {
1294 dprintk(1, KERN_ERR "%s: %s() - ioremap failed\n",
1295 ZR_DEVNAME(zr), __func__);
1296 goto zr_unreg;
1297 }
1298
1299 result = request_irq(zr->pci_dev->irq, zoran_irq,
1300 IRQF_SHARED, ZR_DEVNAME(zr), zr);
1301 if (result < 0) {
1302 if (result == -EINVAL) {
1303 dprintk(1,
1304 KERN_ERR
1305 "%s: %s - bad irq number or handler\n",
1306 ZR_DEVNAME(zr), __func__);
1307 } else if (result == -EBUSY) {
1308 dprintk(1,
1309 KERN_ERR
1310 "%s: %s - IRQ %d busy, change your PnP config in BIOS\n",
1311 ZR_DEVNAME(zr), __func__, zr->pci_dev->irq);
1312 } else {
1313 dprintk(1,
1314 KERN_ERR
1315 "%s: %s - can't assign irq, error code %d\n",
1316 ZR_DEVNAME(zr), __func__, result);
1317 }
1318 goto zr_unmap;
1319 }
1320
1321 /* set PCI latency timer */
1322 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1323 &latency);
1324 need_latency = zr->revision > 1 ? 32 : 48;
1325 if (latency != need_latency) {
1326 dprintk(2, KERN_INFO "%s: Changing PCI latency from %d to %d\n",
1327 ZR_DEVNAME(zr), latency, need_latency);
1328 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1329 need_latency);
1330 }
1331
1332 zr36057_restart(zr);
1333 /* i2c */
1334 dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
1335 ZR_DEVNAME(zr));
1336
1337 if (zoran_register_i2c(zr) < 0) {
1338 dprintk(1, KERN_ERR "%s: %s - can't initialize i2c bus\n",
1339 ZR_DEVNAME(zr), __func__);
1340 goto zr_free_irq;
1341 }
1342
1343 zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1344 &zr->i2c_adapter, zr->card.i2c_decoder,
1345 0, zr->card.addrs_decoder);
1346
1347 if (zr->card.i2c_encoder)
1348 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
1349 &zr->i2c_adapter, zr->card.i2c_encoder,
1350 0, zr->card.addrs_encoder);
1351
1352 dprintk(2,
1353 KERN_INFO "%s: Initializing videocodec bus...\n",
1354 ZR_DEVNAME(zr));
1355
1356 if (zr->card.video_codec) {
1357 codec_name = codecid_to_modulename(zr->card.video_codec);
1358 if (codec_name) {
1359 result = request_module(codec_name);
1360 if (result) {
1361 dprintk(1,
1362 KERN_ERR
1363 "%s: failed to load modules %s: %d\n",
1364 ZR_DEVNAME(zr), codec_name, result);
1365 }
1366 }
1367 }
1368 if (zr->card.video_vfe) {
1369 vfe_name = codecid_to_modulename(zr->card.video_vfe);
1370 if (vfe_name) {
1371 result = request_module(vfe_name);
1372 if (result < 0) {
1373 dprintk(1,
1374 KERN_ERR
1375 "%s: failed to load modules %s: %d\n",
1376 ZR_DEVNAME(zr), vfe_name, result);
1377 }
1378 }
1379 }
1380
1381 /* reset JPEG codec */
1382 jpeg_codec_sleep(zr, 1);
1383 jpeg_codec_reset(zr);
1384 /* video bus enabled */
1385 /* display codec revision */
1386 if (zr->card.video_codec != 0) {
1387 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1388 if (!master_codec)
1389 goto zr_unreg_i2c;
1390 zr->codec = videocodec_attach(master_codec);
1391 if (!zr->codec) {
1392 dprintk(1, KERN_ERR "%s: %s - no codec found\n",
1393 ZR_DEVNAME(zr), __func__);
1394 goto zr_free_codec;
1395 }
1396 if (zr->codec->type != zr->card.video_codec) {
1397 dprintk(1, KERN_ERR "%s: %s - wrong codec\n",
1398 ZR_DEVNAME(zr), __func__);
1399 goto zr_detach_codec;
1400 }
1401 }
1402 if (zr->card.video_vfe != 0) {
1403 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1404 if (!master_vfe)
1405 goto zr_detach_codec;
1406 zr->vfe = videocodec_attach(master_vfe);
1407 if (!zr->vfe) {
1408 dprintk(1, KERN_ERR "%s: %s - no VFE found\n",
1409 ZR_DEVNAME(zr), __func__);
1410 goto zr_free_vfe;
1411 }
1412 if (zr->vfe->type != zr->card.video_vfe) {
1413 dprintk(1, KERN_ERR "%s: %s = wrong VFE\n",
1414 ZR_DEVNAME(zr), __func__);
1415 goto zr_detach_vfe;
1416 }
1417 }
1418
1419 /* take care of Natoma chipset and a revision 1 zr36057 */
1420 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1) {
1421 zr->jpg_buffers.need_contiguous = 1;
1422 dprintk(1, KERN_INFO
1423 "%s: ZR36057/Natoma bug, max. buffer size is 128K\n",
1424 ZR_DEVNAME(zr));
1425 }
1426
1427 if (zr36057_init(zr) < 0)
1428 goto zr_detach_vfe;
1429
1430 zoran_proc_init(zr);
1431
1432 return 0;
1433
1434 zr_detach_vfe:
1435 videocodec_detach(zr->vfe);
1436 zr_free_vfe:
1437 kfree(master_vfe);
1438 zr_detach_codec:
1439 videocodec_detach(zr->codec);
1440 zr_free_codec:
1441 kfree(master_codec);
1442 zr_unreg_i2c:
1443 zoran_unregister_i2c(zr);
1444 zr_free_irq:
1445 btwrite(0, ZR36057_SPGPPCR);
1446 free_irq(zr->pci_dev->irq, zr);
1447 zr_unmap:
1448 iounmap(zr->zr36057_mem);
1449 zr_unreg:
1450 v4l2_ctrl_handler_free(&zr->hdl);
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 = 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 with added FPC-III support