1
2
3
4
5
6
7
8
9
10
11
12#include <linux/delay.h>
13#include <linux/kernel.h>
14#include <linux/module.h>
15#include <linux/slab.h>
16
17#include <linux/i2c.h>
18#include <linux/i2c-algo-bit.h>
19#include <linux/videodev2.h>
20#include <linux/spinlock.h>
21
22#include <linux/pci.h>
23#include <linux/interrupt.h>
24#include <linux/io.h>
25#include <media/v4l2-common.h>
26#include <media/i2c/bt819.h>
27
28#include "videocodec.h"
29#include "zoran.h"
30#include "zoran_card.h"
31#include "zoran_device.h"
32
33extern const struct zoran_format zoran_formats[];
34
35static int card[BUZ_MAX] = { [0 ... (BUZ_MAX - 1)] = -1 };
36module_param_array(card, int, NULL, 0444);
37MODULE_PARM_DESC(card, "Card type");
38
39
40
41
42
43
44
45
46static unsigned long vidmem;
47module_param_hw(vidmem, ulong, iomem, 0444);
48MODULE_PARM_DESC(vidmem, "Default video memory base address");
49
50
51
52static unsigned int default_input;
53module_param(default_input, uint, 0444);
54MODULE_PARM_DESC(default_input,
55 "Default input (0=Composite, 1=S-Video, 2=Internal)");
56
57static int default_mux = 1;
58module_param(default_mux, int, 0644);
59MODULE_PARM_DESC(default_mux,
60 "Default 6 Eyes mux setting (Input selection)");
61
62static int default_norm;
63module_param(default_norm, int, 0444);
64MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
65
66
67static int video_nr[BUZ_MAX] = { [0 ... (BUZ_MAX - 1)] = -1 };
68module_param_array(video_nr, int, NULL, 0444);
69MODULE_PARM_DESC(video_nr, "Video device number (-1=Auto)");
70
71int v4l_nbufs = 4;
72int v4l_bufsize = 864;
73module_param(v4l_nbufs, int, 0644);
74MODULE_PARM_DESC(v4l_nbufs, "Maximum number of V4L buffers to use");
75module_param(v4l_bufsize, int, 0644);
76MODULE_PARM_DESC(v4l_bufsize, "Maximum size per V4L buffer (in kB)");
77
78int jpg_nbufs = 32;
79int jpg_bufsize = 512;
80module_param(jpg_nbufs, int, 0644);
81MODULE_PARM_DESC(jpg_nbufs, "Maximum number of JPG buffers to use");
82module_param(jpg_bufsize, int, 0644);
83MODULE_PARM_DESC(jpg_bufsize, "Maximum size per JPG buffer (in kB)");
84
85
86
87int pass_through;
88module_param(pass_through, int, 0644);
89MODULE_PARM_DESC(pass_through,
90 "Pass TV signal through to TV-out when idling");
91
92int zr36067_debug = 1;
93module_param_named(debug, zr36067_debug, int, 0644);
94MODULE_PARM_DESC(debug, "Debug level (0-5)");
95
96#define ZORAN_VERSION "0.10.1"
97
98MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
99MODULE_AUTHOR("Serguei Miridonov");
100MODULE_LICENSE("GPL");
101MODULE_VERSION(ZORAN_VERSION);
102
103#define ZR_DEVICE(subven, subdev, data) { \
104 .vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \
105 .subvendor = (subven), .subdevice = (subdev), .driver_data = (data) }
106
107static const struct pci_device_id zr36067_pci_tbl[] = {
108 ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC10PLUS, DC10_PLUS),
109 ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC30PLUS, DC30_PLUS),
110 ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH, PCI_DEVICE_ID_LML_33R10, LML33R10),
111 ZR_DEVICE(PCI_VENDOR_ID_IOMEGA, PCI_DEVICE_ID_IOMEGA_BUZ, BUZ),
112 ZR_DEVICE(PCI_ANY_ID, PCI_ANY_ID, NUM_CARDS),
113 {0}
114};
115MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
116
117static unsigned int zoran_num;
118
119
120static u32 zr36060_read(struct videocodec *codec, u16 reg)
121{
122 struct zoran *zr = (struct zoran *)codec->master_data->data;
123 __u32 data;
124
125 if (post_office_wait(zr) || post_office_write(zr, 0, 1, reg >> 8) ||
126 post_office_write(zr, 0, 2, reg & 0xff))
127 return -1;
128
129 data = post_office_read(zr, 0, 3) & 0xff;
130 return data;
131}
132
133static void zr36060_write(struct videocodec *codec, u16 reg, u32 val)
134{
135 struct zoran *zr = (struct zoran *)codec->master_data->data;
136
137 if (post_office_wait(zr) || post_office_write(zr, 0, 1, reg >> 8) ||
138 post_office_write(zr, 0, 2, reg & 0xff))
139 return;
140
141 post_office_write(zr, 0, 3, val & 0xff);
142}
143
144
145static u32 zr36050_read(struct videocodec *codec, u16 reg)
146{
147 struct zoran *zr = (struct zoran *)codec->master_data->data;
148 __u32 data;
149
150 if (post_office_wait(zr) || post_office_write(zr, 1, 0, reg >> 2))
151 return -1;
152
153 data = post_office_read(zr, 0, reg & 0x03) & 0xff;
154 return data;
155}
156
157static void zr36050_write(struct videocodec *codec, u16 reg, u32 val)
158{
159 struct zoran *zr = (struct zoran *)codec->master_data->data;
160
161 if (post_office_wait(zr) || post_office_write(zr, 1, 0, reg >> 2))
162 return;
163
164 post_office_write(zr, 0, reg & 0x03, val & 0xff);
165}
166
167
168static u32 zr36016_read(struct videocodec *codec, u16 reg)
169{
170 struct zoran *zr = (struct zoran *)codec->master_data->data;
171 __u32 data;
172
173 if (post_office_wait(zr))
174 return -1;
175
176 data = post_office_read(zr, 2, reg & 0x03) & 0xff;
177 return data;
178}
179
180
181void zr36016_write(struct videocodec *codec, u16 reg, u32 val)
182{
183 struct zoran *zr = (struct zoran *)codec->master_data->data;
184
185 if (post_office_wait(zr))
186 return;
187
188 post_office_write(zr, 2, reg & 0x03, val & 0x0ff);
189}
190
191
192
193
194
195static void dc10_init(struct zoran *zr)
196{
197 pci_dbg(zr->pci_dev, "%s\n", __func__);
198
199
200 GPIO(zr, 4, 0);
201 GPIO(zr, 5, 1);
202
203 GPIO(zr, 7, 0);
204}
205
206static void dc10plus_init(struct zoran *zr)
207{
208 pci_dbg(zr->pci_dev, "%s\n", __func__);
209}
210
211static void buz_init(struct zoran *zr)
212{
213 pci_dbg(zr->pci_dev, "%s\n", __func__);
214
215
216 pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
217 pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
218 pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
219}
220
221static void lml33_init(struct zoran *zr)
222{
223 pci_dbg(zr->pci_dev, "%s\n", __func__);
224
225 GPIO(zr, 2, 1);
226}
227
228static void avs6eyes_init(struct zoran *zr)
229{
230
231
232
233
234
235 int mux = default_mux;
236
237 GPIO(zr, 4, 1);
238 udelay(2);
239
240 GPIO(zr, 0, 1);
241 GPIO(zr, 1, 0);
242 GPIO(zr, 2, mux & 1);
243 GPIO(zr, 3, 0);
244 GPIO(zr, 4, 0);
245 GPIO(zr, 5, mux & 2);
246 GPIO(zr, 6, 0);
247 GPIO(zr, 7, mux & 4);
248}
249
250static const char *codecid_to_modulename(u16 codecid)
251{
252 const char *name = NULL;
253
254 switch (codecid) {
255 case CODEC_TYPE_ZR36060:
256 name = "zr36060";
257 break;
258 case CODEC_TYPE_ZR36050:
259 name = "zr36050";
260 break;
261 case CODEC_TYPE_ZR36016:
262 name = "zr36016";
263 break;
264 }
265
266 return name;
267}
268
269
270
271
272
273static const struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
274static const struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
275static const struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
276static const struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
277
278static const struct tvnorm f50ccir601_lml33 = { 864, 720, 75 + 34, 804, 625, 576, 18 };
279static const struct tvnorm f60ccir601_lml33 = { 858, 720, 57 + 34, 788, 525, 480, 16 };
280
281
282static const struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
283static const struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
284
285
286
287
288
289static const struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74 + 54, 804, 625, 576, 18 };
290static const struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56 + 54, 788, 525, 480, 16 };
291
292
293
294
295
296
297
298
299static const struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
300static const struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
301
302static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END };
303static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END };
304static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END };
305static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END };
306static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END };
307static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END };
308static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END };
309static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END };
310static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END };
311static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END };
312
313static struct card_info zoran_cards[NUM_CARDS] = {
314 {
315 .type = DC10_OLD,
316 .name = "DC10(old)",
317 .i2c_decoder = "vpx3220a",
318 .addrs_decoder = vpx3220_addrs,
319 .video_codec = CODEC_TYPE_ZR36050,
320 .video_vfe = CODEC_TYPE_ZR36016,
321
322 .inputs = 3,
323 .input = {
324 { 1, "Composite" },
325 { 2, "S-Video" },
326 { 0, "Internal/comp" }
327 },
328 .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
329 .tvn = {
330 &f50sqpixel_dc10,
331 &f60sqpixel_dc10,
332 &f50sqpixel_dc10
333 },
334 .jpeg_int = 0,
335 .vsync_int = ZR36057_ISR_GIRQ1,
336 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
337 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
338 .gpcs = { -1, 0 },
339 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
340 .gws_not_connected = 0,
341 .input_mux = 0,
342 .init = &dc10_init,
343 }, {
344 .type = DC10_NEW,
345 .name = "DC10(new)",
346 .i2c_decoder = "saa7110",
347 .addrs_decoder = saa7110_addrs,
348 .i2c_encoder = "adv7175",
349 .addrs_encoder = adv717x_addrs,
350 .video_codec = CODEC_TYPE_ZR36060,
351
352 .inputs = 3,
353 .input = {
354 { 0, "Composite" },
355 { 7, "S-Video" },
356 { 5, "Internal/comp" }
357 },
358 .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
359 .tvn = {
360 &f50sqpixel,
361 &f60sqpixel,
362 &f50sqpixel},
363 .jpeg_int = ZR36057_ISR_GIRQ0,
364 .vsync_int = ZR36057_ISR_GIRQ1,
365 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
366 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
367 .gpcs = { -1, 1},
368 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
369 .gws_not_connected = 0,
370 .input_mux = 0,
371 .init = &dc10plus_init,
372 }, {
373 .type = DC10_PLUS,
374 .name = "DC10_PLUS",
375 .i2c_decoder = "saa7110",
376 .addrs_decoder = saa7110_addrs,
377 .i2c_encoder = "adv7175",
378 .addrs_encoder = adv717x_addrs,
379 .video_codec = CODEC_TYPE_ZR36060,
380
381 .inputs = 3,
382 .input = {
383 { 0, "Composite" },
384 { 7, "S-Video" },
385 { 5, "Internal/comp" }
386 },
387 .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
388 .tvn = {
389 &f50sqpixel,
390 &f60sqpixel,
391 &f50sqpixel
392 },
393 .jpeg_int = ZR36057_ISR_GIRQ0,
394 .vsync_int = ZR36057_ISR_GIRQ1,
395 .gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
396 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
397 .gpcs = { -1, 1 },
398 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
399 .gws_not_connected = 0,
400 .input_mux = 0,
401 .init = &dc10plus_init,
402 }, {
403 .type = DC30,
404 .name = "DC30",
405 .i2c_decoder = "vpx3220a",
406 .addrs_decoder = vpx3220_addrs,
407 .i2c_encoder = "adv7175",
408 .addrs_encoder = adv717x_addrs,
409 .video_codec = CODEC_TYPE_ZR36050,
410 .video_vfe = CODEC_TYPE_ZR36016,
411
412 .inputs = 3,
413 .input = {
414 { 1, "Composite" },
415 { 2, "S-Video" },
416 { 0, "Internal/comp" }
417 },
418 .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
419 .tvn = {
420 &f50sqpixel_dc10,
421 &f60sqpixel_dc10,
422 &f50sqpixel_dc10
423 },
424 .jpeg_int = 0,
425 .vsync_int = ZR36057_ISR_GIRQ1,
426 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
427 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
428 .gpcs = { -1, 0 },
429 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
430 .gws_not_connected = 0,
431 .input_mux = 0,
432 .init = &dc10_init,
433 }, {
434 .type = DC30_PLUS,
435 .name = "DC30_PLUS",
436 .i2c_decoder = "vpx3220a",
437 .addrs_decoder = vpx3220_addrs,
438 .i2c_encoder = "adv7175",
439 .addrs_encoder = adv717x_addrs,
440 .video_codec = CODEC_TYPE_ZR36050,
441 .video_vfe = CODEC_TYPE_ZR36016,
442
443 .inputs = 3,
444 .input = {
445 { 1, "Composite" },
446 { 2, "S-Video" },
447 { 0, "Internal/comp" }
448 },
449 .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
450 .tvn = {
451 &f50sqpixel_dc10,
452 &f60sqpixel_dc10,
453 &f50sqpixel_dc10
454 },
455 .jpeg_int = 0,
456 .vsync_int = ZR36057_ISR_GIRQ1,
457 .gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
458 .gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
459 .gpcs = { -1, 0 },
460 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
461 .gws_not_connected = 0,
462 .input_mux = 0,
463 .init = &dc10_init,
464 }, {
465 .type = LML33,
466 .name = "LML33",
467 .i2c_decoder = "bt819a",
468 .addrs_decoder = bt819_addrs,
469 .i2c_encoder = "bt856",
470 .addrs_encoder = bt856_addrs,
471 .video_codec = CODEC_TYPE_ZR36060,
472
473 .inputs = 2,
474 .input = {
475 { 0, "Composite" },
476 { 7, "S-Video" }
477 },
478 .norms = V4L2_STD_NTSC | V4L2_STD_PAL,
479 .tvn = {
480 &f50ccir601_lml33,
481 &f60ccir601_lml33,
482 NULL
483 },
484 .jpeg_int = ZR36057_ISR_GIRQ1,
485 .vsync_int = ZR36057_ISR_GIRQ0,
486 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
487 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
488 .gpcs = { 3, 1 },
489 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
490 .gws_not_connected = 1,
491 .input_mux = 0,
492 .init = &lml33_init,
493 }, {
494 .type = LML33R10,
495 .name = "LML33R10",
496 .i2c_decoder = "saa7114",
497 .addrs_decoder = saa7114_addrs,
498 .i2c_encoder = "adv7170",
499 .addrs_encoder = adv717x_addrs,
500 .video_codec = CODEC_TYPE_ZR36060,
501
502 .inputs = 2,
503 .input = {
504 { 0, "Composite" },
505 { 7, "S-Video" }
506 },
507 .norms = V4L2_STD_NTSC | V4L2_STD_PAL,
508 .tvn = {
509 &f50ccir601_lm33r10,
510 &f60ccir601_lm33r10,
511 NULL
512 },
513 .jpeg_int = ZR36057_ISR_GIRQ1,
514 .vsync_int = ZR36057_ISR_GIRQ0,
515 .gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
516 .gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
517 .gpcs = { 3, 1 },
518 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
519 .gws_not_connected = 1,
520 .input_mux = 0,
521 .init = &lml33_init,
522 }, {
523 .type = BUZ,
524 .name = "Buz",
525 .i2c_decoder = "saa7111",
526 .addrs_decoder = saa7111_addrs,
527 .i2c_encoder = "saa7185",
528 .addrs_encoder = saa7185_addrs,
529 .video_codec = CODEC_TYPE_ZR36060,
530
531 .inputs = 2,
532 .input = {
533 { 3, "Composite" },
534 { 7, "S-Video" }
535 },
536 .norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
537 .tvn = {
538 &f50ccir601,
539 &f60ccir601,
540 &f50ccir601
541 },
542 .jpeg_int = ZR36057_ISR_GIRQ1,
543 .vsync_int = ZR36057_ISR_GIRQ0,
544 .gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
545 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
546 .gpcs = { 3, 1 },
547 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
548 .gws_not_connected = 1,
549 .input_mux = 0,
550 .init = &buz_init,
551 }, {
552 .type = AVS6EYES,
553 .name = "6-Eyes",
554
555 .i2c_decoder = "ks0127",
556 .addrs_decoder = ks0127_addrs,
557 .i2c_encoder = "bt866",
558 .addrs_encoder = bt866_addrs,
559 .video_codec = CODEC_TYPE_ZR36060,
560
561 .inputs = 10,
562 .input = {
563 { 0, "Composite 1" },
564 { 1, "Composite 2" },
565 { 2, "Composite 3" },
566 { 4, "Composite 4" },
567 { 5, "Composite 5" },
568 { 6, "Composite 6" },
569 { 8, "S-Video 1" },
570 { 9, "S-Video 2" },
571 {10, "S-Video 3" },
572 {15, "YCbCr" }
573 },
574 .norms = V4L2_STD_NTSC | V4L2_STD_PAL,
575 .tvn = {
576 &f50ccir601_avs6eyes,
577 &f60ccir601_avs6eyes,
578 NULL
579 },
580 .jpeg_int = ZR36057_ISR_GIRQ1,
581 .vsync_int = ZR36057_ISR_GIRQ0,
582 .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },
583 .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
584 .gpcs = { 3, 1 },
585 .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },
586 .gws_not_connected = 1,
587 .input_mux = 1,
588 .init = &avs6eyes_init,
589 }
590
591};
592
593
594
595
596
597static int zoran_i2c_getsda(void *data)
598{
599 struct zoran *zr = (struct zoran *)data;
600
601 return (btread(ZR36057_I2CBR) >> 1) & 1;
602}
603
604static int zoran_i2c_getscl(void *data)
605{
606 struct zoran *zr = (struct zoran *)data;
607
608 return btread(ZR36057_I2CBR) & 1;
609}
610
611static void zoran_i2c_setsda(void *data, int state)
612{
613 struct zoran *zr = (struct zoran *)data;
614
615 if (state)
616 zr->i2cbr |= 2;
617 else
618 zr->i2cbr &= ~2;
619 btwrite(zr->i2cbr, ZR36057_I2CBR);
620}
621
622static void zoran_i2c_setscl(void *data, int state)
623{
624 struct zoran *zr = (struct zoran *)data;
625
626 if (state)
627 zr->i2cbr |= 1;
628 else
629 zr->i2cbr &= ~1;
630 btwrite(zr->i2cbr, ZR36057_I2CBR);
631}
632
633static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
634 .setsda = zoran_i2c_setsda,
635 .setscl = zoran_i2c_setscl,
636 .getsda = zoran_i2c_getsda,
637 .getscl = zoran_i2c_getscl,
638 .udelay = 10,
639 .timeout = 100,
640};
641
642static int zoran_register_i2c(struct zoran *zr)
643{
644 zr->i2c_algo = zoran_i2c_bit_data_template;
645 zr->i2c_algo.data = zr;
646 strscpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
647 sizeof(zr->i2c_adapter.name));
648 i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
649 zr->i2c_adapter.algo_data = &zr->i2c_algo;
650 zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
651 return i2c_bit_add_bus(&zr->i2c_adapter);
652}
653
654static void zoran_unregister_i2c(struct zoran *zr)
655{
656 i2c_del_adapter(&zr->i2c_adapter);
657}
658
659
660int zoran_check_jpg_settings(struct zoran *zr,
661 struct zoran_jpg_settings *settings, int try)
662{
663 int err = 0, err0 = 0;
664
665 pci_dbg(zr->pci_dev, "%s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
666 __func__, settings->decimation, settings->hor_dcm,
667 settings->ver_dcm, settings->tmp_dcm);
668 pci_dbg(zr->pci_dev, "%s - x: %d, y: %d, w: %d, y: %d\n", __func__,
669 settings->img_x, settings->img_y,
670 settings->img_width, settings->img_height);
671
672 switch (settings->decimation) {
673 case 1:
674
675 settings->hor_dcm = 1;
676 settings->ver_dcm = 1;
677 settings->tmp_dcm = 1;
678 settings->field_per_buff = 2;
679 settings->img_x = 0;
680 settings->img_y = 0;
681 settings->img_width = BUZ_MAX_WIDTH;
682 settings->img_height = BUZ_MAX_HEIGHT / 2;
683 break;
684 case 2:
685
686 settings->hor_dcm = 2;
687 settings->ver_dcm = 1;
688 settings->tmp_dcm = 2;
689 settings->field_per_buff = 1;
690 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
691 settings->img_y = 0;
692 settings->img_width =
693 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
694 settings->img_height = BUZ_MAX_HEIGHT / 2;
695 break;
696 case 4:
697
698 if (zr->card.type == DC10_NEW) {
699 pci_dbg(zr->pci_dev, "%s - HDec by 4 is not supported on the DC10\n", __func__);
700 err0++;
701 break;
702 }
703
704 settings->hor_dcm = 4;
705 settings->ver_dcm = 2;
706 settings->tmp_dcm = 2;
707 settings->field_per_buff = 1;
708 settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
709 settings->img_y = 0;
710 settings->img_width =
711 (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
712 settings->img_height = BUZ_MAX_HEIGHT / 2;
713 break;
714 case 0:
715
716
717
718 if (settings->hor_dcm != 1 && settings->hor_dcm != 2 &&
719 (zr->card.type == DC10_NEW || settings->hor_dcm != 4)) {
720 settings->hor_dcm = clamp(settings->hor_dcm, 1, 2);
721 err0++;
722 }
723 if (settings->ver_dcm != 1 && settings->ver_dcm != 2) {
724 settings->ver_dcm = clamp(settings->ver_dcm, 1, 2);
725 err0++;
726 }
727 if (settings->tmp_dcm != 1 && settings->tmp_dcm != 2) {
728 settings->tmp_dcm = clamp(settings->tmp_dcm, 1, 2);
729 err0++;
730 }
731 if (settings->field_per_buff != 1 &&
732 settings->field_per_buff != 2) {
733 settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
734 err0++;
735 }
736 if (settings->img_x < 0) {
737 settings->img_x = 0;
738 err0++;
739 }
740 if (settings->img_y < 0) {
741 settings->img_y = 0;
742 err0++;
743 }
744 if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
745 settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
746 err0++;
747 }
748 if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
749 settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
750 err0++;
751 }
752 if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
753 settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
754 err0++;
755 }
756 if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
757 settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
758 err0++;
759 }
760 if (settings->img_width % (16 * settings->hor_dcm) != 0) {
761 settings->img_width -= settings->img_width % (16 * settings->hor_dcm);
762 if (settings->img_width == 0)
763 settings->img_width = 16 * settings->hor_dcm;
764 err0++;
765 }
766 if (settings->img_height % (8 * settings->ver_dcm) != 0) {
767 settings->img_height -= settings->img_height % (8 * settings->ver_dcm);
768 if (settings->img_height == 0)
769 settings->img_height = 8 * settings->ver_dcm;
770 err0++;
771 }
772
773 if (!try && err0) {
774 pci_err(zr->pci_dev, "%s - error in params for decimation = 0\n", __func__);
775 err++;
776 }
777 break;
778 default:
779 pci_err(zr->pci_dev, "%s - decimation = %d, must be 0, 1, 2 or 4\n",
780 __func__, settings->decimation);
781 err++;
782 break;
783 }
784
785 if (settings->jpg_comp.quality > 100)
786 settings->jpg_comp.quality = 100;
787 if (settings->jpg_comp.quality < 5)
788 settings->jpg_comp.quality = 5;
789 if (settings->jpg_comp.APPn < 0)
790 settings->jpg_comp.APPn = 0;
791 if (settings->jpg_comp.APPn > 15)
792 settings->jpg_comp.APPn = 15;
793 if (settings->jpg_comp.APP_len < 0)
794 settings->jpg_comp.APP_len = 0;
795 if (settings->jpg_comp.APP_len > 60)
796 settings->jpg_comp.APP_len = 60;
797 if (settings->jpg_comp.COM_len < 0)
798 settings->jpg_comp.COM_len = 0;
799 if (settings->jpg_comp.COM_len > 60)
800 settings->jpg_comp.COM_len = 60;
801 if (err)
802 return -EINVAL;
803 return 0;
804}
805
806void zoran_open_init_params(struct zoran *zr)
807{
808 int i;
809
810 zr->v4l_settings.width = 192;
811 zr->v4l_settings.height = 144;
812 zr->v4l_settings.format = &zoran_formats[7];
813 zr->v4l_settings.bytesperline = zr->v4l_settings.width *
814 ((zr->v4l_settings.format->depth + 7) / 8);
815
816
817 zr->jpg_settings.decimation = 1;
818 zr->jpg_settings.jpg_comp.quality = 50;
819 if (zr->card.type != BUZ)
820 zr->jpg_settings.odd_even = 1;
821 else
822 zr->jpg_settings.odd_even = 0;
823 zr->jpg_settings.jpg_comp.APPn = 0;
824 zr->jpg_settings.jpg_comp.APP_len = 0;
825 memset(zr->jpg_settings.jpg_comp.APP_data, 0,
826 sizeof(zr->jpg_settings.jpg_comp.APP_data));
827 zr->jpg_settings.jpg_comp.COM_len = 0;
828 memset(zr->jpg_settings.jpg_comp.COM_data, 0,
829 sizeof(zr->jpg_settings.jpg_comp.COM_data));
830 zr->jpg_settings.jpg_comp.jpeg_markers =
831 V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT;
832 i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
833 if (i)
834 pci_err(zr->pci_dev, "%s internal error\n", __func__);
835
836 zr->buffer_size = zr->v4l_settings.bytesperline * zr->v4l_settings.height;
837
838 clear_interrupt_counters(zr);
839}
840
841static int zr36057_init(struct zoran *zr)
842{
843 int j, err;
844
845 pci_info(zr->pci_dev, "initializing card[%d]\n", zr->id);
846
847
848 if (default_norm < 0 || default_norm > 2)
849 default_norm = 0;
850 if (default_norm == 0) {
851 zr->norm = V4L2_STD_PAL;
852 zr->timing = zr->card.tvn[ZR_NORM_PAL];
853 } else if (default_norm == 1) {
854 zr->norm = V4L2_STD_NTSC;
855 zr->timing = zr->card.tvn[ZR_NORM_NTSC];
856 } else {
857 zr->norm = V4L2_STD_SECAM;
858 zr->timing = zr->card.tvn[ZR_NORM_SECAM];
859 }
860 if (!zr->timing) {
861 pci_warn(zr->pci_dev, "%s - default TV standard not supported by hardware. PAL will be used.\n", __func__);
862 zr->norm = V4L2_STD_PAL;
863 zr->timing = zr->card.tvn[ZR_NORM_PAL];
864 }
865
866 if (default_input > zr->card.inputs - 1) {
867 pci_warn(zr->pci_dev, "default_input value %d out of range (0-%d)\n",
868 default_input, zr->card.inputs - 1);
869 default_input = 0;
870 }
871 zr->input = default_input;
872
873
874 zoran_open_init_params(zr);
875
876
877 zr->video_dev = video_device_alloc();
878 if (!zr->video_dev) {
879 err = -ENOMEM;
880 goto exit;
881 }
882 zr->stat_com = dma_alloc_coherent(&zr->pci_dev->dev,
883 BUZ_NUM_STAT_COM * sizeof(u32),
884 &zr->p_sc, GFP_KERNEL);
885 if (!zr->stat_com) {
886 err = -ENOMEM;
887 goto exit_video;
888 }
889 for (j = 0; j < BUZ_NUM_STAT_COM; j++)
890 zr->stat_com[j] = cpu_to_le32(1);
891
892 zr->stat_comb = dma_alloc_coherent(&zr->pci_dev->dev,
893 BUZ_NUM_STAT_COM * sizeof(u32) * 2,
894 &zr->p_scb, GFP_KERNEL);
895 if (!zr->stat_comb) {
896 err = -ENOMEM;
897 goto exit_statcom;
898 }
899
900
901 *zr->video_dev = zoran_template;
902 zr->video_dev->v4l2_dev = &zr->v4l2_dev;
903 zr->video_dev->lock = &zr->lock;
904 zr->video_dev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE;
905
906 strscpy(zr->video_dev->name, ZR_DEVNAME(zr), sizeof(zr->video_dev->name));
907
908
909
910
911
912 zr->video_dev->vfl_dir = VFL_DIR_M2M;
913
914 zoran_queue_init(zr, &zr->vq);
915
916 err = video_register_device(zr->video_dev, VFL_TYPE_VIDEO, video_nr[zr->id]);
917 if (err < 0)
918 goto exit_statcomb;
919 video_set_drvdata(zr->video_dev, zr);
920
921 zoran_init_hardware(zr);
922 if (!pass_through) {
923 decoder_call(zr, video, s_stream, 0);
924 encoder_call(zr, video, s_routing, 2, 0, 0);
925 }
926
927 zr->initialized = 1;
928 return 0;
929
930exit_statcomb:
931 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2, zr->stat_comb, zr->p_scb);
932exit_statcom:
933 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32), zr->stat_com, zr->p_sc);
934exit_video:
935 kfree(zr->video_dev);
936exit:
937 return err;
938}
939
940static void zoran_remove(struct pci_dev *pdev)
941{
942 struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
943 struct zoran *zr = to_zoran(v4l2_dev);
944
945 if (!zr->initialized)
946 goto exit_free;
947
948 zoran_queue_exit(zr);
949
950
951 if (zr->codec)
952 videocodec_detach(zr->codec);
953 if (zr->vfe)
954 videocodec_detach(zr->vfe);
955
956
957 zoran_unregister_i2c(zr);
958
959 zoran_set_pci_master(zr, 0);
960
961 btwrite(0, ZR36057_SPGPPCR);
962 pci_free_irq(zr->pci_dev, 0, zr);
963
964 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32), zr->stat_com, zr->p_sc);
965 dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2, zr->stat_comb, zr->p_scb);
966 pci_release_regions(pdev);
967 pci_disable_device(zr->pci_dev);
968 video_unregister_device(zr->video_dev);
969exit_free:
970 v4l2_ctrl_handler_free(&zr->hdl);
971 v4l2_device_unregister(&zr->v4l2_dev);
972}
973
974void zoran_vdev_release(struct video_device *vdev)
975{
976 kfree(vdev);
977}
978
979static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr,
980 int type)
981{
982 struct videocodec_master *m = NULL;
983
984 m = devm_kmalloc(&zr->pci_dev->dev, sizeof(*m), GFP_KERNEL);
985 if (!m)
986 return m;
987
988
989
990
991
992
993 m->magic = 0L;
994 m->type = 0;
995
996 m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
997 strscpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
998 m->data = zr;
999
1000 switch (type) {
1001 case CODEC_TYPE_ZR36060:
1002 m->readreg = zr36060_read;
1003 m->writereg = zr36060_write;
1004 m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1005 break;
1006 case CODEC_TYPE_ZR36050:
1007 m->readreg = zr36050_read;
1008 m->writereg = zr36050_write;
1009 m->flags |= CODEC_FLAG_JPEG;
1010 break;
1011 case CODEC_TYPE_ZR36016:
1012 m->readreg = zr36016_read;
1013 m->writereg = zr36016_write;
1014 m->flags |= CODEC_FLAG_VFE;
1015 break;
1016 }
1017
1018 return m;
1019}
1020
1021static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1022{
1023 struct zoran *zr = to_zoran(sd->v4l2_dev);
1024
1025
1026
1027
1028
1029 if (cmd == BT819_FIFO_RESET_LOW)
1030 GPIO(zr, 7, 0);
1031 else if (cmd == BT819_FIFO_RESET_HIGH)
1032 GPIO(zr, 7, 1);
1033}
1034
1035static int zoran_video_set_ctrl(struct v4l2_ctrl *ctrl)
1036{
1037 struct zoran *zr = container_of(ctrl->handler, struct zoran, hdl);
1038
1039 switch (ctrl->id) {
1040 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1041 zr->jpg_settings.jpg_comp.quality = ctrl->val;
1042 return zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
1043 default:
1044 return -EINVAL;
1045 }
1046
1047 return 0;
1048}
1049
1050static const struct v4l2_ctrl_ops zoran_video_ctrl_ops = {
1051 .s_ctrl = zoran_video_set_ctrl,
1052};
1053
1054
1055
1056
1057
1058static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1059{
1060 unsigned char latency, need_latency;
1061 struct zoran *zr;
1062 int result;
1063 struct videocodec_master *master_vfe = NULL;
1064 struct videocodec_master *master_codec = NULL;
1065 int card_num;
1066 const char *codec_name, *vfe_name;
1067 unsigned int nr;
1068 int err;
1069
1070 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1071 if (err)
1072 return -ENODEV;
1073 vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
1074
1075 nr = zoran_num++;
1076 if (nr >= BUZ_MAX) {
1077 pci_err(pdev, "driver limited to %d card(s) maximum\n", BUZ_MAX);
1078 return -ENOENT;
1079 }
1080
1081 zr = devm_kzalloc(&pdev->dev, sizeof(*zr), GFP_KERNEL);
1082 if (!zr)
1083 return -ENOMEM;
1084
1085 zr->v4l2_dev.notify = zoran_subdev_notify;
1086 if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1087 goto zr_free_mem;
1088 zr->pci_dev = pdev;
1089 zr->id = nr;
1090 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1091 if (v4l2_ctrl_handler_init(&zr->hdl, 10))
1092 goto zr_unreg;
1093 zr->v4l2_dev.ctrl_handler = &zr->hdl;
1094 v4l2_ctrl_new_std(&zr->hdl, &zoran_video_ctrl_ops,
1095 V4L2_CID_JPEG_COMPRESSION_QUALITY, 0,
1096 100, 1, 50);
1097 spin_lock_init(&zr->spinlock);
1098 mutex_init(&zr->lock);
1099 if (pci_enable_device(pdev))
1100 goto zr_unreg;
1101 zr->revision = zr->pci_dev->revision;
1102
1103 pci_info(zr->pci_dev, "Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1104 zr->revision < 2 ? '5' : '6', zr->revision,
1105 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1106 if (zr->revision >= 2)
1107 pci_info(zr->pci_dev, "Subsystem vendor=0x%04x id=0x%04x\n",
1108 zr->pci_dev->subsystem_vendor, zr->pci_dev->subsystem_device);
1109
1110
1111 if (card[nr] == -1) {
1112 if (zr->revision < 2) {
1113 pci_err(pdev, "No card type specified, please use the card=X module parameter\n");
1114 pci_err(pdev, "It is not possible to auto-detect ZR36057 based cards\n");
1115 goto zr_unreg;
1116 }
1117
1118 card_num = ent->driver_data;
1119 if (card_num >= NUM_CARDS) {
1120 pci_err(pdev, "Unknown card, try specifying card=X module parameter\n");
1121 goto zr_unreg;
1122 }
1123 pci_info(zr->pci_dev, "%s() - card %s detected\n", __func__, zoran_cards[card_num].name);
1124 } else {
1125 card_num = card[nr];
1126 if (card_num >= NUM_CARDS || card_num < 0) {
1127 pci_err(pdev, "User specified card type %d out of range (0 .. %d)\n",
1128 card_num, NUM_CARDS - 1);
1129 goto zr_unreg;
1130 }
1131 }
1132
1133
1134
1135
1136
1137
1138
1139
1140 zr->card = zoran_cards[card_num];
1141 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "%s[%u]",
1142 zr->card.name, zr->id);
1143
1144 err = pci_request_regions(pdev, ZR_DEVNAME(zr));
1145 if (err)
1146 goto zr_unreg;
1147
1148 zr->zr36057_mem = devm_ioremap(&pdev->dev, pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
1149 if (!zr->zr36057_mem) {
1150 pci_err(pdev, "%s() - ioremap failed\n", __func__);
1151 goto zr_pci_release;
1152 }
1153
1154 result = pci_request_irq(pdev, 0, zoran_irq, NULL, zr, ZR_DEVNAME(zr));
1155 if (result < 0) {
1156 if (result == -EINVAL) {
1157 pci_err(pdev, "%s - bad IRQ number or handler\n", __func__);
1158 } else if (result == -EBUSY) {
1159 pci_err(pdev, "%s - IRQ %d busy, change your PnP config in BIOS\n",
1160 __func__, zr->pci_dev->irq);
1161 } else {
1162 pci_err(pdev, "%s - cannot assign IRQ, error code %d\n", __func__, result);
1163 }
1164 goto zr_pci_release;
1165 }
1166
1167
1168 pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1169 &latency);
1170 need_latency = zr->revision > 1 ? 32 : 48;
1171 if (latency != need_latency) {
1172 pci_info(zr->pci_dev, "Changing PCI latency from %d to %d\n", latency, need_latency);
1173 pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, need_latency);
1174 }
1175
1176 zr36057_restart(zr);
1177
1178 pci_info(zr->pci_dev, "Initializing i2c bus...\n");
1179
1180 if (zoran_register_i2c(zr) < 0) {
1181 pci_err(pdev, "%s - can't initialize i2c bus\n", __func__);
1182 goto zr_free_irq;
1183 }
1184
1185 zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, &zr->i2c_adapter,
1186 zr->card.i2c_decoder, 0,
1187 zr->card.addrs_decoder);
1188
1189 if (zr->card.i2c_encoder)
1190 zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, &zr->i2c_adapter,
1191 zr->card.i2c_encoder, 0,
1192 zr->card.addrs_encoder);
1193
1194 pci_info(zr->pci_dev, "Initializing videocodec bus...\n");
1195
1196 if (zr->card.video_codec) {
1197 codec_name = codecid_to_modulename(zr->card.video_codec);
1198 if (codec_name) {
1199 result = request_module(codec_name);
1200 if (result)
1201 pci_err(pdev, "failed to load modules %s: %d\n", codec_name, result);
1202 }
1203 }
1204 if (zr->card.video_vfe) {
1205 vfe_name = codecid_to_modulename(zr->card.video_vfe);
1206 if (vfe_name) {
1207 result = request_module(vfe_name);
1208 if (result < 0)
1209 pci_err(pdev, "failed to load modules %s: %d\n", vfe_name, result);
1210 }
1211 }
1212
1213
1214 jpeg_codec_sleep(zr, 1);
1215 jpeg_codec_reset(zr);
1216
1217
1218 if (zr->card.video_codec != 0) {
1219 master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1220 if (!master_codec)
1221 goto zr_unreg_i2c;
1222 zr->codec = videocodec_attach(master_codec);
1223 if (!zr->codec) {
1224 pci_err(pdev, "%s - no codec found\n", __func__);
1225 goto zr_unreg_i2c;
1226 }
1227 if (zr->codec->type != zr->card.video_codec) {
1228 pci_err(pdev, "%s - wrong codec\n", __func__);
1229 goto zr_detach_codec;
1230 }
1231 }
1232 if (zr->card.video_vfe != 0) {
1233 master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1234 if (!master_vfe)
1235 goto zr_detach_codec;
1236 zr->vfe = videocodec_attach(master_vfe);
1237 if (!zr->vfe) {
1238 pci_err(pdev, "%s - no VFE found\n", __func__);
1239 goto zr_detach_codec;
1240 }
1241 if (zr->vfe->type != zr->card.video_vfe) {
1242 pci_err(pdev, "%s = wrong VFE\n", __func__);
1243 goto zr_detach_vfe;
1244 }
1245 }
1246
1247
1248 if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1)
1249 pci_info(zr->pci_dev, "ZR36057/Natoma bug, max. buffer size is 128K\n");
1250
1251 if (zr36057_init(zr) < 0)
1252 goto zr_detach_vfe;
1253
1254 zr->map_mode = ZORAN_MAP_MODE_RAW;
1255
1256 return 0;
1257
1258zr_detach_vfe:
1259 videocodec_detach(zr->vfe);
1260zr_detach_codec:
1261 videocodec_detach(zr->codec);
1262zr_unreg_i2c:
1263 zoran_unregister_i2c(zr);
1264zr_free_irq:
1265 btwrite(0, ZR36057_SPGPPCR);
1266 pci_free_irq(zr->pci_dev, 0, zr);
1267zr_pci_release:
1268 pci_release_regions(pdev);
1269zr_unreg:
1270 v4l2_ctrl_handler_free(&zr->hdl);
1271 v4l2_device_unregister(&zr->v4l2_dev);
1272zr_free_mem:
1273
1274 return -ENODEV;
1275}
1276
1277static struct pci_driver zoran_driver = {
1278 .name = "zr36067",
1279 .id_table = zr36067_pci_tbl,
1280 .probe = zoran_probe,
1281 .remove = zoran_remove,
1282};
1283
1284static int __init zoran_init(void)
1285{
1286 int res;
1287
1288 pr_info("Zoran MJPEG board driver version %s\n", ZORAN_VERSION);
1289
1290
1291 if (v4l_nbufs < 2)
1292 v4l_nbufs = 2;
1293 if (v4l_nbufs > VIDEO_MAX_FRAME)
1294 v4l_nbufs = VIDEO_MAX_FRAME;
1295
1296 v4l_bufsize = PAGE_ALIGN(v4l_bufsize * 1024);
1297 if (v4l_bufsize < 32768)
1298 v4l_bufsize = 32768;
1299
1300 if (v4l_bufsize > 2048 * 1024)
1301 v4l_bufsize = 2048 * 1024;
1302 if (jpg_nbufs < 4)
1303 jpg_nbufs = 4;
1304 if (jpg_nbufs > BUZ_MAX_FRAME)
1305 jpg_nbufs = BUZ_MAX_FRAME;
1306 jpg_bufsize = PAGE_ALIGN(jpg_bufsize * 1024);
1307 if (jpg_bufsize < 8192)
1308 jpg_bufsize = 8192;
1309 if (jpg_bufsize > (512 * 1024))
1310 jpg_bufsize = 512 * 1024;
1311
1312 if (vidmem)
1313 pr_info("%s: Using supplied video memory base address @ 0x%lx\n", ZORAN_NAME, vidmem);
1314
1315
1316 if (pci_pci_problems & (PCIPCI_FAIL | PCIAGP_FAIL | PCIPCI_ALIMAGIK))
1317 pr_warn("%s: chipset does not support reliable PCI-PCI DMA\n", ZORAN_NAME);
1318
1319 res = pci_register_driver(&zoran_driver);
1320 if (res) {
1321 pr_err("Unable to register ZR36057 driver\n");
1322 return res;
1323 }
1324
1325 return 0;
1326}
1327
1328static void __exit zoran_exit(void)
1329{
1330 pci_unregister_driver(&zoran_driver);
1331}
1332
1333module_init(zoran_init);
1334module_exit(zoran_exit);
1335