1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38
39#include <linux/init.h>
40#include <linux/module.h>
41#include <linux/delay.h>
42#include <linux/slab.h>
43#include <linux/errno.h>
44#include <linux/fs.h>
45#include <linux/kernel.h>
46#include <linux/sched.h>
47#include <linux/interrupt.h>
48#include <linux/kdev_t.h>
49#include "bttvp.h"
50#include <media/v4l2-common.h>
51#include <media/v4l2-ioctl.h>
52#include <media/v4l2-event.h>
53#include <media/tvaudio.h>
54#include <media/msp3400.h>
55
56#include <linux/dma-mapping.h>
57
58#include <asm/io.h>
59#include <asm/byteorder.h>
60
61#include <media/saa6588.h>
62
63#define BTTV_VERSION "0.9.19"
64
65unsigned int bttv_num;
66struct bttv *bttvs[BTTV_MAX];
67
68unsigned int bttv_debug;
69unsigned int bttv_verbose = 1;
70unsigned int bttv_gpio;
71
72
73#ifdef __BIG_ENDIAN
74static unsigned int bigendian=1;
75#else
76static unsigned int bigendian;
77#endif
78static unsigned int radio[BTTV_MAX];
79static unsigned int irq_debug;
80static unsigned int gbuffers = 8;
81static unsigned int gbufsize = 0x208000;
82static unsigned int reset_crop = 1;
83
84static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
85static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
86static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
87static int debug_latency;
88static int disable_ir;
89
90static unsigned int fdsr;
91
92
93static unsigned int combfilter;
94static unsigned int lumafilter;
95static unsigned int automute = 1;
96static unsigned int chroma_agc;
97static unsigned int agc_crush = 1;
98static unsigned int whitecrush_upper = 0xCF;
99static unsigned int whitecrush_lower = 0x7F;
100static unsigned int vcr_hack;
101static unsigned int irq_iswitch;
102static unsigned int uv_ratio = 50;
103static unsigned int full_luma_range;
104static unsigned int coring;
105
106
107static unsigned int v4l2 = 1;
108
109
110module_param(bttv_verbose, int, 0644);
111module_param(bttv_gpio, int, 0644);
112module_param(bttv_debug, int, 0644);
113module_param(irq_debug, int, 0644);
114module_param(debug_latency, int, 0644);
115module_param(disable_ir, int, 0444);
116
117module_param(fdsr, int, 0444);
118module_param(gbuffers, int, 0444);
119module_param(gbufsize, int, 0444);
120module_param(reset_crop, int, 0444);
121
122module_param(v4l2, int, 0644);
123module_param(bigendian, int, 0644);
124module_param(irq_iswitch, int, 0644);
125module_param(combfilter, int, 0444);
126module_param(lumafilter, int, 0444);
127module_param(automute, int, 0444);
128module_param(chroma_agc, int, 0444);
129module_param(agc_crush, int, 0444);
130module_param(whitecrush_upper, int, 0444);
131module_param(whitecrush_lower, int, 0444);
132module_param(vcr_hack, int, 0444);
133module_param(uv_ratio, int, 0444);
134module_param(full_luma_range, int, 0444);
135module_param(coring, int, 0444);
136
137module_param_array(radio, int, NULL, 0444);
138module_param_array(video_nr, int, NULL, 0444);
139module_param_array(radio_nr, int, NULL, 0444);
140module_param_array(vbi_nr, int, NULL, 0444);
141
142MODULE_PARM_DESC(radio, "The TV card supports radio, default is 0 (no)");
143MODULE_PARM_DESC(bigendian, "byte order of the framebuffer, default is native endian");
144MODULE_PARM_DESC(bttv_verbose, "verbose startup messages, default is 1 (yes)");
145MODULE_PARM_DESC(bttv_gpio, "log gpio changes, default is 0 (no)");
146MODULE_PARM_DESC(bttv_debug, "debug messages, default is 0 (no)");
147MODULE_PARM_DESC(irq_debug, "irq handler debug messages, default is 0 (no)");
148MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
149MODULE_PARM_DESC(gbuffers, "number of capture buffers. range 2-32, default 8");
150MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 0x208000");
151MODULE_PARM_DESC(reset_crop, "reset cropping parameters at open(), default "
152 "is 1 (yes) for compatibility with older applications");
153MODULE_PARM_DESC(automute, "mute audio on bad/missing video signal, default is 1 (yes)");
154MODULE_PARM_DESC(chroma_agc, "enables the AGC of chroma signal, default is 0 (no)");
155MODULE_PARM_DESC(agc_crush, "enables the luminance AGC crush, default is 1 (yes)");
156MODULE_PARM_DESC(whitecrush_upper, "sets the white crush upper value, default is 207");
157MODULE_PARM_DESC(whitecrush_lower, "sets the white crush lower value, default is 127");
158MODULE_PARM_DESC(vcr_hack, "enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
159MODULE_PARM_DESC(irq_iswitch, "switch inputs in irq handler");
160MODULE_PARM_DESC(uv_ratio, "ratio between u and v gains, default is 50");
161MODULE_PARM_DESC(full_luma_range, "use the full luma range, default is 0 (no)");
162MODULE_PARM_DESC(coring, "set the luma coring level, default is 0 (no)");
163MODULE_PARM_DESC(video_nr, "video device numbers");
164MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
165MODULE_PARM_DESC(radio_nr, "radio device numbers");
166
167MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
168MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
169MODULE_LICENSE("GPL");
170MODULE_VERSION(BTTV_VERSION);
171
172#define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_USER_BTTV_BASE + 0)
173#define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_USER_BTTV_BASE + 1)
174#define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_USER_BTTV_BASE + 2)
175#define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_USER_BTTV_BASE + 3)
176#define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_USER_BTTV_BASE + 4)
177#define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_USER_BTTV_BASE + 5)
178#define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_USER_BTTV_BASE + 6)
179#define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_USER_BTTV_BASE + 7)
180#define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_USER_BTTV_BASE + 8)
181#define V4L2_CID_PRIVATE_CORING (V4L2_CID_USER_BTTV_BASE + 9)
182
183
184
185
186static ssize_t show_card(struct device *cd,
187 struct device_attribute *attr, char *buf)
188{
189 struct video_device *vfd = container_of(cd, struct video_device, dev);
190 struct bttv *btv = video_get_drvdata(vfd);
191 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
192}
193static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
194
195
196
197#if defined(CONFIG_MODULES) && defined(MODULE)
198static void request_module_async(struct work_struct *work)
199{
200 request_module("dvb-bt8xx");
201}
202
203static void request_modules(struct bttv *dev)
204{
205 INIT_WORK(&dev->request_module_wk, request_module_async);
206 schedule_work(&dev->request_module_wk);
207}
208
209static void flush_request_modules(struct bttv *dev)
210{
211 flush_work(&dev->request_module_wk);
212}
213#else
214#define request_modules(dev)
215#define flush_request_modules(dev) do {} while(0)
216#endif
217
218
219
220
221
222
223static u8 SRAM_Table[][60] =
224{
225
226 {
227 45,
228 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
229 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
230 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
231 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
232 0x37,0x00,0xAF,0x21,0x00
233 },
234
235 {
236 51,
237 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
238 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
239 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
240 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
241 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
242 0x00,
243 },
244
245
246 {
247 0x2A,
248 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
249 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
250 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
251 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
252 0x20, 0x00
253 }
254};
255
256
257
258
259
260
261
262
263
264
265
266
267
268#define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
269 vdelay, sheight, extraheight, videostart0) \
270 .cropcap.bounds.left = minhdelayx1, \
271 \
272 \
273 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
274 \
275 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
276 .cropcap.bounds.height = (sheight) + (extraheight) + (vdelay) - \
277 MIN_VDELAY, \
278 .cropcap.defrect.left = hdelayx1, \
279 .cropcap.defrect.top = (videostart0) * 2, \
280 .cropcap.defrect.width = swidth, \
281 .cropcap.defrect.height = sheight, \
282 .cropcap.pixelaspect.numerator = totalwidth, \
283 .cropcap.pixelaspect.denominator = sqwidth,
284
285const struct bttv_tvnorm bttv_tvnorms[] = {
286
287
288
289 {
290 .v4l2_id = V4L2_STD_PAL,
291 .name = "PAL",
292 .Fsc = 35468950,
293 .swidth = 924,
294 .sheight = 576,
295 .totalwidth = 1135,
296 .adelay = 0x7f,
297 .bdelay = 0x72,
298 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
299 .scaledtwidth = 1135,
300 .hdelayx1 = 186,
301 .hactivex1 = 924,
302 .vdelay = 0x20,
303 .vbipack = 255,
304 .sram = 0,
305
306
307
308 .vbistart = { 7, 320 },
309 CROPCAP( 68,
310 186,
311
312
313
314 924,
315 1135,
316 944,
317 0x20,
318 576,
319
320
321 2,
322 23)
323 },{
324 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
325 .name = "NTSC",
326 .Fsc = 28636363,
327 .swidth = 768,
328 .sheight = 480,
329 .totalwidth = 910,
330 .adelay = 0x68,
331 .bdelay = 0x5d,
332 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
333 .scaledtwidth = 910,
334 .hdelayx1 = 128,
335 .hactivex1 = 910,
336 .vdelay = 0x1a,
337 .vbipack = 144,
338 .sram = 1,
339 .vbistart = { 10, 273 },
340 CROPCAP( 68,
341 128,
342
343 768,
344 910,
345 780,
346 0x1a,
347 480,
348 0,
349 23)
350 },{
351 .v4l2_id = V4L2_STD_SECAM,
352 .name = "SECAM",
353 .Fsc = 35468950,
354 .swidth = 924,
355 .sheight = 576,
356 .totalwidth = 1135,
357 .adelay = 0x7f,
358 .bdelay = 0xb0,
359 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
360 .scaledtwidth = 1135,
361 .hdelayx1 = 186,
362 .hactivex1 = 922,
363 .vdelay = 0x20,
364 .vbipack = 255,
365 .sram = 0,
366 .vbistart = { 7, 320 },
367 CROPCAP( 68,
368 186,
369 924,
370 1135,
371 944,
372 0x20,
373 576,
374 0,
375 23)
376 },{
377 .v4l2_id = V4L2_STD_PAL_Nc,
378 .name = "PAL-Nc",
379 .Fsc = 28636363,
380 .swidth = 640,
381 .sheight = 576,
382 .totalwidth = 910,
383 .adelay = 0x68,
384 .bdelay = 0x5d,
385 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
386 .scaledtwidth = 780,
387 .hdelayx1 = 130,
388 .hactivex1 = 734,
389 .vdelay = 0x1a,
390 .vbipack = 144,
391 .sram = -1,
392 .vbistart = { 7, 320 },
393 CROPCAP( 68,
394 130,
395 (640 * 910 + 780 / 2) / 780,
396 910,
397 780,
398 0x1a,
399 576,
400 0,
401 23)
402 },{
403 .v4l2_id = V4L2_STD_PAL_M,
404 .name = "PAL-M",
405 .Fsc = 28636363,
406 .swidth = 640,
407 .sheight = 480,
408 .totalwidth = 910,
409 .adelay = 0x68,
410 .bdelay = 0x5d,
411 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
412 .scaledtwidth = 780,
413 .hdelayx1 = 135,
414 .hactivex1 = 754,
415 .vdelay = 0x1a,
416 .vbipack = 144,
417 .sram = -1,
418 .vbistart = { 10, 273 },
419 CROPCAP( 68,
420 135,
421 (640 * 910 + 780 / 2) / 780,
422 910,
423 780,
424 0x1a,
425 480,
426 0,
427 23)
428 },{
429 .v4l2_id = V4L2_STD_PAL_N,
430 .name = "PAL-N",
431 .Fsc = 35468950,
432 .swidth = 768,
433 .sheight = 576,
434 .totalwidth = 1135,
435 .adelay = 0x7f,
436 .bdelay = 0x72,
437 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
438 .scaledtwidth = 944,
439 .hdelayx1 = 186,
440 .hactivex1 = 922,
441 .vdelay = 0x20,
442 .vbipack = 144,
443 .sram = -1,
444 .vbistart = { 7, 320 },
445 CROPCAP( 68,
446 186,
447 (768 * 1135 + 944 / 2) / 944,
448 1135,
449 944,
450 0x20,
451 576,
452 0,
453 23)
454 },{
455 .v4l2_id = V4L2_STD_NTSC_M_JP,
456 .name = "NTSC-JP",
457 .Fsc = 28636363,
458 .swidth = 640,
459 .sheight = 480,
460 .totalwidth = 910,
461 .adelay = 0x68,
462 .bdelay = 0x5d,
463 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
464 .scaledtwidth = 780,
465 .hdelayx1 = 135,
466 .hactivex1 = 754,
467 .vdelay = 0x16,
468 .vbipack = 144,
469 .sram = -1,
470 .vbistart = { 10, 273 },
471 CROPCAP( 68,
472 135,
473 (640 * 910 + 780 / 2) / 780,
474 910,
475 780,
476 0x16,
477 480,
478 0,
479 23)
480 },{
481
482
483
484 .v4l2_id = V4L2_STD_PAL_60,
485 .name = "PAL-60",
486 .Fsc = 35468950,
487 .swidth = 924,
488 .sheight = 480,
489 .totalwidth = 1135,
490 .adelay = 0x7f,
491 .bdelay = 0x72,
492 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
493 .scaledtwidth = 1135,
494 .hdelayx1 = 186,
495 .hactivex1 = 924,
496 .vdelay = 0x1a,
497 .vbipack = 255,
498 .vtotal = 524,
499 .sram = -1,
500 .vbistart = { 10, 273 },
501 CROPCAP( 68,
502 186,
503 924,
504 1135,
505 944,
506 0x1a,
507 480,
508 0,
509 23)
510 }
511};
512static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
513
514
515
516
517static const struct bttv_format formats[] = {
518 {
519 .name = "8 bpp, gray",
520 .fourcc = V4L2_PIX_FMT_GREY,
521 .btformat = BT848_COLOR_FMT_Y8,
522 .depth = 8,
523 .flags = FORMAT_FLAGS_PACKED,
524 },{
525 .name = "8 bpp, dithered color",
526 .fourcc = V4L2_PIX_FMT_HI240,
527 .btformat = BT848_COLOR_FMT_RGB8,
528 .depth = 8,
529 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
530 },{
531 .name = "15 bpp RGB, le",
532 .fourcc = V4L2_PIX_FMT_RGB555,
533 .btformat = BT848_COLOR_FMT_RGB15,
534 .depth = 16,
535 .flags = FORMAT_FLAGS_PACKED,
536 },{
537 .name = "15 bpp RGB, be",
538 .fourcc = V4L2_PIX_FMT_RGB555X,
539 .btformat = BT848_COLOR_FMT_RGB15,
540 .btswap = 0x03,
541 .depth = 16,
542 .flags = FORMAT_FLAGS_PACKED,
543 },{
544 .name = "16 bpp RGB, le",
545 .fourcc = V4L2_PIX_FMT_RGB565,
546 .btformat = BT848_COLOR_FMT_RGB16,
547 .depth = 16,
548 .flags = FORMAT_FLAGS_PACKED,
549 },{
550 .name = "16 bpp RGB, be",
551 .fourcc = V4L2_PIX_FMT_RGB565X,
552 .btformat = BT848_COLOR_FMT_RGB16,
553 .btswap = 0x03,
554 .depth = 16,
555 .flags = FORMAT_FLAGS_PACKED,
556 },{
557 .name = "24 bpp RGB, le",
558 .fourcc = V4L2_PIX_FMT_BGR24,
559 .btformat = BT848_COLOR_FMT_RGB24,
560 .depth = 24,
561 .flags = FORMAT_FLAGS_PACKED,
562 },{
563 .name = "32 bpp RGB, le",
564 .fourcc = V4L2_PIX_FMT_BGR32,
565 .btformat = BT848_COLOR_FMT_RGB32,
566 .depth = 32,
567 .flags = FORMAT_FLAGS_PACKED,
568 },{
569 .name = "32 bpp RGB, be",
570 .fourcc = V4L2_PIX_FMT_RGB32,
571 .btformat = BT848_COLOR_FMT_RGB32,
572 .btswap = 0x0f,
573 .depth = 32,
574 .flags = FORMAT_FLAGS_PACKED,
575 },{
576 .name = "4:2:2, packed, YUYV",
577 .fourcc = V4L2_PIX_FMT_YUYV,
578 .btformat = BT848_COLOR_FMT_YUY2,
579 .depth = 16,
580 .flags = FORMAT_FLAGS_PACKED,
581 },{
582 .name = "4:2:2, packed, UYVY",
583 .fourcc = V4L2_PIX_FMT_UYVY,
584 .btformat = BT848_COLOR_FMT_YUY2,
585 .btswap = 0x03,
586 .depth = 16,
587 .flags = FORMAT_FLAGS_PACKED,
588 },{
589 .name = "4:2:2, planar, Y-Cb-Cr",
590 .fourcc = V4L2_PIX_FMT_YUV422P,
591 .btformat = BT848_COLOR_FMT_YCrCb422,
592 .depth = 16,
593 .flags = FORMAT_FLAGS_PLANAR,
594 .hshift = 1,
595 .vshift = 0,
596 },{
597 .name = "4:2:0, planar, Y-Cb-Cr",
598 .fourcc = V4L2_PIX_FMT_YUV420,
599 .btformat = BT848_COLOR_FMT_YCrCb422,
600 .depth = 12,
601 .flags = FORMAT_FLAGS_PLANAR,
602 .hshift = 1,
603 .vshift = 1,
604 },{
605 .name = "4:2:0, planar, Y-Cr-Cb",
606 .fourcc = V4L2_PIX_FMT_YVU420,
607 .btformat = BT848_COLOR_FMT_YCrCb422,
608 .depth = 12,
609 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
610 .hshift = 1,
611 .vshift = 1,
612 },{
613 .name = "4:1:1, planar, Y-Cb-Cr",
614 .fourcc = V4L2_PIX_FMT_YUV411P,
615 .btformat = BT848_COLOR_FMT_YCrCb411,
616 .depth = 12,
617 .flags = FORMAT_FLAGS_PLANAR,
618 .hshift = 2,
619 .vshift = 0,
620 },{
621 .name = "4:1:0, planar, Y-Cb-Cr",
622 .fourcc = V4L2_PIX_FMT_YUV410,
623 .btformat = BT848_COLOR_FMT_YCrCb411,
624 .depth = 9,
625 .flags = FORMAT_FLAGS_PLANAR,
626 .hshift = 2,
627 .vshift = 2,
628 },{
629 .name = "4:1:0, planar, Y-Cr-Cb",
630 .fourcc = V4L2_PIX_FMT_YVU410,
631 .btformat = BT848_COLOR_FMT_YCrCb411,
632 .depth = 9,
633 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
634 .hshift = 2,
635 .vshift = 2,
636 },{
637 .name = "raw scanlines",
638 .fourcc = -1,
639 .btformat = BT848_COLOR_FMT_RAW,
640 .depth = 8,
641 .flags = FORMAT_FLAGS_RAW,
642 }
643};
644static const unsigned int FORMATS = ARRAY_SIZE(formats);
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677#define VBI_RESOURCES (RESOURCE_VBI)
678#define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
679 RESOURCE_VIDEO_STREAM | \
680 RESOURCE_OVERLAY)
681
682static
683int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit)
684{
685 int xbits;
686
687 if (fh->resources & bit)
688
689 return 1;
690
691 xbits = bit;
692 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
693 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
694
695
696 if (btv->resources & xbits) {
697
698 goto fail;
699 }
700
701 if ((bit & VIDEO_RESOURCES)
702 && 0 == (btv->resources & VIDEO_RESOURCES)) {
703
704 __s32 top = btv->crop[!!fh->do_crop].rect.top;
705
706 if (btv->vbi_end > top)
707 goto fail;
708
709
710
711 btv->crop_start = top;
712 } else if (bit & VBI_RESOURCES) {
713 __s32 end = fh->vbi_fmt.end;
714
715 if (end > btv->crop_start)
716 goto fail;
717
718
719 btv->vbi_end = end;
720 }
721
722
723 fh->resources |= bit;
724 btv->resources |= bit;
725 return 1;
726
727 fail:
728 return 0;
729}
730
731static
732int check_btres(struct bttv_fh *fh, int bit)
733{
734 return (fh->resources & bit);
735}
736
737static
738int locked_btres(struct bttv *btv, int bit)
739{
740 return (btv->resources & bit);
741}
742
743
744static void
745disclaim_vbi_lines(struct bttv *btv)
746{
747 btv->vbi_end = 0;
748}
749
750
751static void
752disclaim_video_lines(struct bttv *btv)
753{
754 const struct bttv_tvnorm *tvnorm;
755 u8 crop;
756
757 tvnorm = &bttv_tvnorms[btv->tvnorm];
758 btv->crop_start = tvnorm->cropcap.bounds.top
759 + tvnorm->cropcap.bounds.height;
760
761
762
763
764
765 crop = btread(BT848_E_CROP) | 0xc0;
766 btwrite(crop, BT848_E_CROP);
767 btwrite(0xfe, BT848_E_VDELAY_LO);
768 btwrite(crop, BT848_O_CROP);
769 btwrite(0xfe, BT848_O_VDELAY_LO);
770}
771
772static
773void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits)
774{
775 if ((fh->resources & bits) != bits) {
776
777 pr_err("BUG! (btres)\n");
778 }
779 fh->resources &= ~bits;
780 btv->resources &= ~bits;
781
782 bits = btv->resources;
783
784 if (0 == (bits & VIDEO_RESOURCES))
785 disclaim_video_lines(btv);
786
787 if (0 == (bits & VBI_RESOURCES))
788 disclaim_vbi_lines(btv);
789}
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
805{
806 unsigned char fl, fh, fi;
807
808
809 fin/=4;
810 fout/=4;
811
812 fout*=12;
813 fi=fout/fin;
814
815 fout=(fout%fin)*256;
816 fh=fout/fin;
817
818 fout=(fout%fin)*256;
819 fl=fout/fin;
820
821 btwrite(fl, BT848_PLL_F_LO);
822 btwrite(fh, BT848_PLL_F_HI);
823 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
824}
825
826static void set_pll(struct bttv *btv)
827{
828 int i;
829
830 if (!btv->pll.pll_crystal)
831 return;
832
833 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
834 dprintk("%d: PLL: no change required\n", btv->c.nr);
835 return;
836 }
837
838 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
839
840 if (btv->pll.pll_current == 0)
841 return;
842 if (bttv_verbose)
843 pr_info("%d: PLL can sleep, using XTAL (%d)\n",
844 btv->c.nr, btv->pll.pll_ifreq);
845 btwrite(0x00,BT848_TGCTRL);
846 btwrite(0x00,BT848_PLL_XCI);
847 btv->pll.pll_current = 0;
848 return;
849 }
850
851 if (bttv_verbose)
852 pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n",
853 btv->c.nr,
854 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
855 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
856
857 for (i=0; i<10; i++) {
858
859 msleep(10);
860
861 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
862 btwrite(0,BT848_DSTATUS);
863 } else {
864 btwrite(0x08,BT848_TGCTRL);
865 btv->pll.pll_current = btv->pll.pll_ofreq;
866 if (bttv_verbose)
867 pr_info("PLL set ok\n");
868 return;
869 }
870 }
871 btv->pll.pll_current = -1;
872 if (bttv_verbose)
873 pr_info("Setting PLL failed\n");
874 return;
875}
876
877
878static void bt848A_set_timing(struct bttv *btv)
879{
880 int i, len;
881 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
882 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
883
884 if (btv->input == btv->dig) {
885 dprintk("%d: load digital timing table (table_idx=%d)\n",
886 btv->c.nr,table_idx);
887
888
889 btwrite(0x00, BT848_TGCTRL);
890 btwrite(0x02, BT848_TGCTRL);
891 btwrite(0x00, BT848_TGCTRL);
892
893 len=SRAM_Table[table_idx][0];
894 for(i = 1; i <= len; i++)
895 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
896 btv->pll.pll_ofreq = 27000000;
897
898 set_pll(btv);
899 btwrite(0x11, BT848_TGCTRL);
900 btwrite(0x41, BT848_DVSIF);
901 } else {
902 btv->pll.pll_ofreq = fsc;
903 set_pll(btv);
904 btwrite(0x0, BT848_DVSIF);
905 }
906}
907
908
909
910static void bt848_bright(struct bttv *btv, int bright)
911{
912 int value;
913
914
915 btv->bright = bright;
916
917
918 value = (bright >> 8) - 128;
919 btwrite(value & 0xff, BT848_BRIGHT);
920}
921
922static void bt848_hue(struct bttv *btv, int hue)
923{
924 int value;
925
926 btv->hue = hue;
927
928
929 value = (hue >> 8) - 128;
930 btwrite(value & 0xff, BT848_HUE);
931}
932
933static void bt848_contrast(struct bttv *btv, int cont)
934{
935 int value,hibit;
936
937 btv->contrast = cont;
938
939
940 value = (cont >> 7);
941 hibit = (value >> 6) & 4;
942 btwrite(value & 0xff, BT848_CONTRAST_LO);
943 btaor(hibit, ~4, BT848_E_CONTROL);
944 btaor(hibit, ~4, BT848_O_CONTROL);
945}
946
947static void bt848_sat(struct bttv *btv, int color)
948{
949 int val_u,val_v,hibits;
950
951 btv->saturation = color;
952
953
954 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
955 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
956 hibits = (val_u >> 7) & 2;
957 hibits |= (val_v >> 8) & 1;
958 btwrite(val_u & 0xff, BT848_SAT_U_LO);
959 btwrite(val_v & 0xff, BT848_SAT_V_LO);
960 btaor(hibits, ~3, BT848_E_CONTROL);
961 btaor(hibits, ~3, BT848_O_CONTROL);
962}
963
964
965
966static int
967video_mux(struct bttv *btv, unsigned int input)
968{
969 int mux,mask2;
970
971 if (input >= bttv_tvcards[btv->c.type].video_inputs)
972 return -EINVAL;
973
974
975 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
976 if (mask2)
977 gpio_inout(mask2,mask2);
978
979 if (input == btv->svhs) {
980 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
981 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
982 } else {
983 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
984 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
985 }
986 mux = bttv_muxsel(btv, input);
987 btaor(mux<<5, ~(3<<5), BT848_IFORM);
988 dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux);
989
990
991 if(bttv_tvcards[btv->c.type].muxsel_hook)
992 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
993 return 0;
994}
995
996static char *audio_modes[] = {
997 "audio: tuner", "audio: radio", "audio: extern",
998 "audio: intern", "audio: mute"
999};
1000
1001static void
1002audio_mux_gpio(struct bttv *btv, int input, int mute)
1003{
1004 int gpio_val, signal, mute_gpio;
1005
1006 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1007 bttv_tvcards[btv->c.type].gpiomask);
1008 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1009
1010
1011 mute_gpio = mute || (btv->opt_automute && (!signal || !btv->users)
1012 && !btv->has_radio_tuner);
1013
1014 if (mute_gpio)
1015 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1016 else
1017 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1018
1019 switch (btv->c.type) {
1020 case BTTV_BOARD_VOODOOTV_FM:
1021 case BTTV_BOARD_VOODOOTV_200:
1022 gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
1023 break;
1024
1025 default:
1026 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1027 }
1028
1029 if (bttv_gpio)
1030 bttv_gpio_tracking(btv, audio_modes[mute_gpio ? 4 : input]);
1031}
1032
1033static int
1034audio_mute(struct bttv *btv, int mute)
1035{
1036 struct v4l2_ctrl *ctrl;
1037
1038 audio_mux_gpio(btv, btv->audio_input, mute);
1039
1040 if (btv->sd_msp34xx) {
1041 ctrl = v4l2_ctrl_find(btv->sd_msp34xx->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1042 if (ctrl)
1043 v4l2_ctrl_s_ctrl(ctrl, mute);
1044 }
1045 if (btv->sd_tvaudio) {
1046 ctrl = v4l2_ctrl_find(btv->sd_tvaudio->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1047 if (ctrl)
1048 v4l2_ctrl_s_ctrl(ctrl, mute);
1049 }
1050 if (btv->sd_tda7432) {
1051 ctrl = v4l2_ctrl_find(btv->sd_tda7432->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1052 if (ctrl)
1053 v4l2_ctrl_s_ctrl(ctrl, mute);
1054 }
1055 return 0;
1056}
1057
1058static int
1059audio_input(struct bttv *btv, int input)
1060{
1061 audio_mux_gpio(btv, input, btv->mute);
1062
1063 if (btv->sd_msp34xx) {
1064 u32 in;
1065
1066
1067
1068
1069
1070
1071 switch (input) {
1072 case TVAUDIO_INPUT_RADIO:
1073
1074 if (btv->radio_uses_msp_demodulator) {
1075 in = MSP_INPUT_DEFAULT;
1076 break;
1077 }
1078 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1079 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1080 break;
1081 case TVAUDIO_INPUT_EXTERN:
1082 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1083 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1084 break;
1085 case TVAUDIO_INPUT_INTERN:
1086
1087
1088
1089
1090
1091 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1092 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1093 break;
1094 case TVAUDIO_INPUT_TUNER:
1095 default:
1096
1097
1098
1099 if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1100 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1101 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1102 else
1103 in = MSP_INPUT_DEFAULT;
1104 break;
1105 }
1106 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1107 in, MSP_OUTPUT_DEFAULT, 0);
1108 }
1109 if (btv->sd_tvaudio) {
1110 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1111 input, 0, 0);
1112 }
1113 return 0;
1114}
1115
1116static void
1117bttv_crop_calc_limits(struct bttv_crop *c)
1118{
1119
1120
1121
1122 if (1) {
1123
1124
1125 c->min_scaled_width = 48;
1126 c->min_scaled_height = 32;
1127 } else {
1128 c->min_scaled_width =
1129 (max(48, c->rect.width >> 4) + 3) & ~3;
1130 c->min_scaled_height =
1131 max(32, c->rect.height >> 4);
1132 }
1133
1134 c->max_scaled_width = c->rect.width & ~3;
1135 c->max_scaled_height = c->rect.height;
1136}
1137
1138static void
1139bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1140{
1141 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1142 bttv_crop_calc_limits(c);
1143}
1144
1145
1146static int
1147set_tvnorm(struct bttv *btv, unsigned int norm)
1148{
1149 const struct bttv_tvnorm *tvnorm;
1150 v4l2_std_id id;
1151
1152 BUG_ON(norm >= BTTV_TVNORMS);
1153 BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
1154
1155 tvnorm = &bttv_tvnorms[norm];
1156
1157 if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1158 sizeof (tvnorm->cropcap))) {
1159 bttv_crop_reset(&btv->crop[0], norm);
1160 btv->crop[1] = btv->crop[0];
1161
1162 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1163 btv->crop_start = tvnorm->cropcap.bounds.top
1164 + tvnorm->cropcap.bounds.height;
1165 }
1166 }
1167
1168 btv->tvnorm = norm;
1169
1170 btwrite(tvnorm->adelay, BT848_ADELAY);
1171 btwrite(tvnorm->bdelay, BT848_BDELAY);
1172 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1173 BT848_IFORM);
1174 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1175 btwrite(1, BT848_VBI_PACK_DEL);
1176 bt848A_set_timing(btv);
1177
1178 switch (btv->c.type) {
1179 case BTTV_BOARD_VOODOOTV_FM:
1180 case BTTV_BOARD_VOODOOTV_200:
1181 bttv_tda9880_setnorm(btv, gpio_read());
1182 break;
1183 }
1184 id = tvnorm->v4l2_id;
1185 bttv_call_all(btv, core, s_std, id);
1186
1187 return 0;
1188}
1189
1190
1191static void
1192set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1193{
1194 unsigned long flags;
1195
1196 btv->input = input;
1197 if (irq_iswitch) {
1198 spin_lock_irqsave(&btv->s_lock,flags);
1199 if (btv->curr.frame_irq) {
1200
1201 btv->new_input = input;
1202 } else {
1203 video_mux(btv,input);
1204 }
1205 spin_unlock_irqrestore(&btv->s_lock,flags);
1206 } else {
1207 video_mux(btv,input);
1208 }
1209 btv->audio_input = (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1210 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN;
1211 audio_input(btv, btv->audio_input);
1212 set_tvnorm(btv, norm);
1213}
1214
1215static void init_irqreg(struct bttv *btv)
1216{
1217
1218 btwrite(0xfffffUL, BT848_INT_STAT);
1219
1220 if (bttv_tvcards[btv->c.type].no_video) {
1221
1222 btwrite(BT848_INT_I2CDONE,
1223 BT848_INT_MASK);
1224 } else {
1225
1226 btwrite((btv->triton1) |
1227 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1228 BT848_INT_SCERR |
1229 (fdsr ? BT848_INT_FDSR : 0) |
1230 BT848_INT_RISCI | BT848_INT_OCERR |
1231 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1232 BT848_INT_I2CDONE,
1233 BT848_INT_MASK);
1234 }
1235}
1236
1237static void init_bt848(struct bttv *btv)
1238{
1239 if (bttv_tvcards[btv->c.type].no_video) {
1240
1241 init_irqreg(btv);
1242 return;
1243 }
1244
1245 btwrite(0x00, BT848_CAP_CTL);
1246 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1247 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1248
1249
1250
1251 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1252 BT848_GPIO_DMA_CTL_PLTP1_16|
1253 BT848_GPIO_DMA_CTL_PLTP23_16|
1254 BT848_GPIO_DMA_CTL_GPINTC|
1255 BT848_GPIO_DMA_CTL_GPINTI,
1256 BT848_GPIO_DMA_CTL);
1257
1258 btwrite(0x20, BT848_E_VSCALE_HI);
1259 btwrite(0x20, BT848_O_VSCALE_HI);
1260
1261 v4l2_ctrl_handler_setup(&btv->ctrl_handler);
1262
1263
1264 init_irqreg(btv);
1265}
1266
1267static void bttv_reinit_bt848(struct bttv *btv)
1268{
1269 unsigned long flags;
1270
1271 if (bttv_verbose)
1272 pr_info("%d: reset, reinitialize\n", btv->c.nr);
1273 spin_lock_irqsave(&btv->s_lock,flags);
1274 btv->errors=0;
1275 bttv_set_dma(btv,0);
1276 spin_unlock_irqrestore(&btv->s_lock,flags);
1277
1278 init_bt848(btv);
1279 btv->pll.pll_current = -1;
1280 set_input(btv, btv->input, btv->tvnorm);
1281}
1282
1283static int bttv_s_ctrl(struct v4l2_ctrl *c)
1284{
1285 struct bttv *btv = container_of(c->handler, struct bttv, ctrl_handler);
1286 int val;
1287
1288 switch (c->id) {
1289 case V4L2_CID_BRIGHTNESS:
1290 bt848_bright(btv, c->val);
1291 break;
1292 case V4L2_CID_HUE:
1293 bt848_hue(btv, c->val);
1294 break;
1295 case V4L2_CID_CONTRAST:
1296 bt848_contrast(btv, c->val);
1297 break;
1298 case V4L2_CID_SATURATION:
1299 bt848_sat(btv, c->val);
1300 break;
1301 case V4L2_CID_COLOR_KILLER:
1302 if (c->val) {
1303 btor(BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1304 btor(BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1305 } else {
1306 btand(~BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1307 btand(~BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1308 }
1309 break;
1310 case V4L2_CID_AUDIO_MUTE:
1311 audio_mute(btv, c->val);
1312 btv->mute = c->val;
1313 break;
1314 case V4L2_CID_AUDIO_VOLUME:
1315 btv->volume_gpio(btv, c->val);
1316 break;
1317
1318 case V4L2_CID_CHROMA_AGC:
1319 val = c->val ? BT848_SCLOOP_CAGC : 0;
1320 btwrite(val, BT848_E_SCLOOP);
1321 btwrite(val, BT848_O_SCLOOP);
1322 break;
1323 case V4L2_CID_PRIVATE_COMBFILTER:
1324 btv->opt_combfilter = c->val;
1325 break;
1326 case V4L2_CID_PRIVATE_LUMAFILTER:
1327 if (c->val) {
1328 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1329 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1330 } else {
1331 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1332 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1333 }
1334 break;
1335 case V4L2_CID_PRIVATE_AUTOMUTE:
1336 btv->opt_automute = c->val;
1337 break;
1338 case V4L2_CID_PRIVATE_AGC_CRUSH:
1339 btwrite(BT848_ADC_RESERVED |
1340 (c->val ? BT848_ADC_CRUSH : 0),
1341 BT848_ADC);
1342 break;
1343 case V4L2_CID_PRIVATE_VCR_HACK:
1344 btv->opt_vcr_hack = c->val;
1345 break;
1346 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1347 btwrite(c->val, BT848_WC_UP);
1348 break;
1349 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1350 btwrite(c->val, BT848_WC_DOWN);
1351 break;
1352 case V4L2_CID_PRIVATE_UV_RATIO:
1353 btv->opt_uv_ratio = c->val;
1354 bt848_sat(btv, btv->saturation);
1355 break;
1356 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1357 btaor((c->val << 7), ~BT848_OFORM_RANGE, BT848_OFORM);
1358 break;
1359 case V4L2_CID_PRIVATE_CORING:
1360 btaor((c->val << 5), ~BT848_OFORM_CORE32, BT848_OFORM);
1361 break;
1362 default:
1363 return -EINVAL;
1364 }
1365 return 0;
1366}
1367
1368
1369
1370static const struct v4l2_ctrl_ops bttv_ctrl_ops = {
1371 .s_ctrl = bttv_s_ctrl,
1372};
1373
1374static struct v4l2_ctrl_config bttv_ctrl_combfilter = {
1375 .ops = &bttv_ctrl_ops,
1376 .id = V4L2_CID_PRIVATE_COMBFILTER,
1377 .name = "Comb Filter",
1378 .type = V4L2_CTRL_TYPE_BOOLEAN,
1379 .min = 0,
1380 .max = 1,
1381 .step = 1,
1382 .def = 1,
1383};
1384
1385static struct v4l2_ctrl_config bttv_ctrl_automute = {
1386 .ops = &bttv_ctrl_ops,
1387 .id = V4L2_CID_PRIVATE_AUTOMUTE,
1388 .name = "Auto Mute",
1389 .type = V4L2_CTRL_TYPE_BOOLEAN,
1390 .min = 0,
1391 .max = 1,
1392 .step = 1,
1393 .def = 1,
1394};
1395
1396static struct v4l2_ctrl_config bttv_ctrl_lumafilter = {
1397 .ops = &bttv_ctrl_ops,
1398 .id = V4L2_CID_PRIVATE_LUMAFILTER,
1399 .name = "Luma Decimation Filter",
1400 .type = V4L2_CTRL_TYPE_BOOLEAN,
1401 .min = 0,
1402 .max = 1,
1403 .step = 1,
1404 .def = 1,
1405};
1406
1407static struct v4l2_ctrl_config bttv_ctrl_agc_crush = {
1408 .ops = &bttv_ctrl_ops,
1409 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
1410 .name = "AGC Crush",
1411 .type = V4L2_CTRL_TYPE_BOOLEAN,
1412 .min = 0,
1413 .max = 1,
1414 .step = 1,
1415 .def = 1,
1416};
1417
1418static struct v4l2_ctrl_config bttv_ctrl_vcr_hack = {
1419 .ops = &bttv_ctrl_ops,
1420 .id = V4L2_CID_PRIVATE_VCR_HACK,
1421 .name = "VCR Hack",
1422 .type = V4L2_CTRL_TYPE_BOOLEAN,
1423 .min = 0,
1424 .max = 1,
1425 .step = 1,
1426 .def = 1,
1427};
1428
1429static struct v4l2_ctrl_config bttv_ctrl_whitecrush_lower = {
1430 .ops = &bttv_ctrl_ops,
1431 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
1432 .name = "Whitecrush Lower",
1433 .type = V4L2_CTRL_TYPE_INTEGER,
1434 .min = 0,
1435 .max = 255,
1436 .step = 1,
1437 .def = 0x7f,
1438};
1439
1440static struct v4l2_ctrl_config bttv_ctrl_whitecrush_upper = {
1441 .ops = &bttv_ctrl_ops,
1442 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
1443 .name = "Whitecrush Upper",
1444 .type = V4L2_CTRL_TYPE_INTEGER,
1445 .min = 0,
1446 .max = 255,
1447 .step = 1,
1448 .def = 0xcf,
1449};
1450
1451static struct v4l2_ctrl_config bttv_ctrl_uv_ratio = {
1452 .ops = &bttv_ctrl_ops,
1453 .id = V4L2_CID_PRIVATE_UV_RATIO,
1454 .name = "UV Ratio",
1455 .type = V4L2_CTRL_TYPE_INTEGER,
1456 .min = 0,
1457 .max = 100,
1458 .step = 1,
1459 .def = 50,
1460};
1461
1462static struct v4l2_ctrl_config bttv_ctrl_full_luma = {
1463 .ops = &bttv_ctrl_ops,
1464 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
1465 .name = "Full Luma Range",
1466 .type = V4L2_CTRL_TYPE_BOOLEAN,
1467 .min = 0,
1468 .max = 1,
1469 .step = 1,
1470};
1471
1472static struct v4l2_ctrl_config bttv_ctrl_coring = {
1473 .ops = &bttv_ctrl_ops,
1474 .id = V4L2_CID_PRIVATE_CORING,
1475 .name = "Coring",
1476 .type = V4L2_CTRL_TYPE_INTEGER,
1477 .min = 0,
1478 .max = 3,
1479 .step = 1,
1480};
1481
1482
1483
1484
1485void bttv_gpio_tracking(struct bttv *btv, char *comment)
1486{
1487 unsigned int outbits, data;
1488 outbits = btread(BT848_GPIO_OUT_EN);
1489 data = btread(BT848_GPIO_DATA);
1490 pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1491 btv->c.nr, outbits, data & outbits, data & ~outbits, comment);
1492}
1493
1494static void bttv_field_count(struct bttv *btv)
1495{
1496 int need_count = 0;
1497
1498 if (btv->users)
1499 need_count++;
1500
1501 if (need_count) {
1502
1503 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1504 } else {
1505
1506 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1507 btv->field_count = 0;
1508 }
1509}
1510
1511static const struct bttv_format*
1512format_by_fourcc(int fourcc)
1513{
1514 unsigned int i;
1515
1516 for (i = 0; i < FORMATS; i++) {
1517 if (-1 == formats[i].fourcc)
1518 continue;
1519 if (formats[i].fourcc == fourcc)
1520 return formats+i;
1521 }
1522 return NULL;
1523}
1524
1525
1526
1527
1528static int
1529bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1530 struct bttv_buffer *new)
1531{
1532 struct bttv_buffer *old;
1533 unsigned long flags;
1534 int retval = 0;
1535
1536 dprintk("switch_overlay: enter [new=%p]\n", new);
1537 if (new)
1538 new->vb.state = VIDEOBUF_DONE;
1539 spin_lock_irqsave(&btv->s_lock,flags);
1540 old = btv->screen;
1541 btv->screen = new;
1542 btv->loop_irq |= 1;
1543 bttv_set_dma(btv, 0x03);
1544 spin_unlock_irqrestore(&btv->s_lock,flags);
1545 if (NULL != old) {
1546 dprintk("switch_overlay: old=%p state is %d\n",
1547 old, old->vb.state);
1548 bttv_dma_free(&fh->cap,btv, old);
1549 kfree(old);
1550 }
1551 if (NULL == new)
1552 free_btres_lock(btv,fh,RESOURCE_OVERLAY);
1553 dprintk("switch_overlay: done\n");
1554 return retval;
1555}
1556
1557
1558
1559
1560static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1561 struct bttv_buffer *buf,
1562 const struct bttv_format *fmt,
1563 unsigned int width, unsigned int height,
1564 enum v4l2_field field)
1565{
1566 struct bttv_fh *fh = q->priv_data;
1567 int redo_dma_risc = 0;
1568 struct bttv_crop c;
1569 int norm;
1570 int rc;
1571
1572
1573 if (NULL == fmt)
1574 return -EINVAL;
1575 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1576 width = RAW_BPL;
1577 height = RAW_LINES*2;
1578 if (width*height > buf->vb.bsize)
1579 return -EINVAL;
1580 buf->vb.size = buf->vb.bsize;
1581
1582
1583
1584
1585 norm = btv->tvnorm;
1586
1587
1588
1589 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1590 return -EINVAL;
1591 }
1592
1593 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1594 } else {
1595 norm = btv->tvnorm;
1596 c = btv->crop[!!fh->do_crop];
1597
1598 if (width < c.min_scaled_width ||
1599 width > c.max_scaled_width ||
1600 height < c.min_scaled_height)
1601 return -EINVAL;
1602
1603 switch (field) {
1604 case V4L2_FIELD_TOP:
1605 case V4L2_FIELD_BOTTOM:
1606 case V4L2_FIELD_ALTERNATE:
1607
1608
1609 if (height * 2 > c.max_scaled_height)
1610 return -EINVAL;
1611 break;
1612
1613 default:
1614 if (height > c.max_scaled_height)
1615 return -EINVAL;
1616 break;
1617 }
1618
1619 buf->vb.size = (width * height * fmt->depth) >> 3;
1620 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1621 return -EINVAL;
1622 }
1623
1624
1625 if (buf->vb.width != width || buf->vb.height != height ||
1626 buf->vb.field != field ||
1627 buf->tvnorm != norm || buf->fmt != fmt ||
1628 buf->crop.top != c.rect.top ||
1629 buf->crop.left != c.rect.left ||
1630 buf->crop.width != c.rect.width ||
1631 buf->crop.height != c.rect.height) {
1632 buf->vb.width = width;
1633 buf->vb.height = height;
1634 buf->vb.field = field;
1635 buf->tvnorm = norm;
1636 buf->fmt = fmt;
1637 buf->crop = c.rect;
1638 redo_dma_risc = 1;
1639 }
1640
1641
1642 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1643 redo_dma_risc = 1;
1644 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1645 goto fail;
1646 }
1647
1648 if (redo_dma_risc)
1649 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1650 goto fail;
1651
1652 buf->vb.state = VIDEOBUF_PREPARED;
1653 return 0;
1654
1655 fail:
1656 bttv_dma_free(q,btv,buf);
1657 return rc;
1658}
1659
1660static int
1661buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1662{
1663 struct bttv_fh *fh = q->priv_data;
1664
1665 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1666 if (0 == *count)
1667 *count = gbuffers;
1668 if (*size * *count > gbuffers * gbufsize)
1669 *count = (gbuffers * gbufsize) / *size;
1670 return 0;
1671}
1672
1673static int
1674buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1675 enum v4l2_field field)
1676{
1677 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1678 struct bttv_fh *fh = q->priv_data;
1679
1680 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1681 fh->width, fh->height, field);
1682}
1683
1684static void
1685buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1686{
1687 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1688 struct bttv_fh *fh = q->priv_data;
1689 struct bttv *btv = fh->btv;
1690
1691 buf->vb.state = VIDEOBUF_QUEUED;
1692 list_add_tail(&buf->vb.queue,&btv->capture);
1693 if (!btv->curr.frame_irq) {
1694 btv->loop_irq |= 1;
1695 bttv_set_dma(btv, 0x03);
1696 }
1697}
1698
1699static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1700{
1701 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1702 struct bttv_fh *fh = q->priv_data;
1703
1704 bttv_dma_free(q,fh->btv,buf);
1705}
1706
1707static struct videobuf_queue_ops bttv_video_qops = {
1708 .buf_setup = buffer_setup,
1709 .buf_prepare = buffer_prepare,
1710 .buf_queue = buffer_queue,
1711 .buf_release = buffer_release,
1712};
1713
1714static void radio_enable(struct bttv *btv)
1715{
1716
1717 if (!btv->has_radio_tuner) {
1718 btv->has_radio_tuner = 1;
1719 bttv_call_all(btv, tuner, s_radio);
1720 btv->audio_input = TVAUDIO_INPUT_RADIO;
1721 audio_input(btv, btv->audio_input);
1722 }
1723}
1724
1725static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id)
1726{
1727 struct bttv_fh *fh = priv;
1728 struct bttv *btv = fh->btv;
1729 unsigned int i;
1730 int err = 0;
1731
1732 for (i = 0; i < BTTV_TVNORMS; i++)
1733 if (id & bttv_tvnorms[i].v4l2_id)
1734 break;
1735 if (i == BTTV_TVNORMS) {
1736 err = -EINVAL;
1737 goto err;
1738 }
1739
1740 btv->std = id;
1741 set_tvnorm(btv, i);
1742
1743err:
1744
1745 return err;
1746}
1747
1748static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id)
1749{
1750 struct bttv_fh *fh = priv;
1751 struct bttv *btv = fh->btv;
1752
1753 *id = btv->std;
1754 return 0;
1755}
1756
1757static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1758{
1759 struct bttv_fh *fh = f;
1760 struct bttv *btv = fh->btv;
1761
1762 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1763 *id &= V4L2_STD_625_50;
1764 else
1765 *id &= V4L2_STD_525_60;
1766 return 0;
1767}
1768
1769static int bttv_enum_input(struct file *file, void *priv,
1770 struct v4l2_input *i)
1771{
1772 struct bttv_fh *fh = priv;
1773 struct bttv *btv = fh->btv;
1774 int rc = 0;
1775
1776 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) {
1777 rc = -EINVAL;
1778 goto err;
1779 }
1780
1781 i->type = V4L2_INPUT_TYPE_CAMERA;
1782 i->audioset = 0;
1783
1784 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1785 sprintf(i->name, "Television");
1786 i->type = V4L2_INPUT_TYPE_TUNER;
1787 i->tuner = 0;
1788 } else if (i->index == btv->svhs) {
1789 sprintf(i->name, "S-Video");
1790 } else {
1791 sprintf(i->name, "Composite%d", i->index);
1792 }
1793
1794 if (i->index == btv->input) {
1795 __u32 dstatus = btread(BT848_DSTATUS);
1796 if (0 == (dstatus & BT848_DSTATUS_PRES))
1797 i->status |= V4L2_IN_ST_NO_SIGNAL;
1798 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1799 i->status |= V4L2_IN_ST_NO_H_LOCK;
1800 }
1801
1802 i->std = BTTV_NORMS;
1803
1804err:
1805
1806 return rc;
1807}
1808
1809static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1810{
1811 struct bttv_fh *fh = priv;
1812 struct bttv *btv = fh->btv;
1813
1814 *i = btv->input;
1815
1816 return 0;
1817}
1818
1819static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1820{
1821 struct bttv_fh *fh = priv;
1822 struct bttv *btv = fh->btv;
1823
1824 if (i >= bttv_tvcards[btv->c.type].video_inputs)
1825 return -EINVAL;
1826
1827 set_input(btv, i, btv->tvnorm);
1828 return 0;
1829}
1830
1831static int bttv_s_tuner(struct file *file, void *priv,
1832 const struct v4l2_tuner *t)
1833{
1834 struct bttv_fh *fh = priv;
1835 struct bttv *btv = fh->btv;
1836
1837 if (t->index)
1838 return -EINVAL;
1839
1840 bttv_call_all(btv, tuner, s_tuner, t);
1841
1842 if (btv->audio_mode_gpio) {
1843 struct v4l2_tuner copy = *t;
1844
1845 btv->audio_mode_gpio(btv, ©, 1);
1846 }
1847 return 0;
1848}
1849
1850static int bttv_g_frequency(struct file *file, void *priv,
1851 struct v4l2_frequency *f)
1852{
1853 struct bttv_fh *fh = priv;
1854 struct bttv *btv = fh->btv;
1855
1856 if (f->tuner)
1857 return -EINVAL;
1858
1859 if (f->type == V4L2_TUNER_RADIO)
1860 radio_enable(btv);
1861 f->frequency = f->type == V4L2_TUNER_RADIO ?
1862 btv->radio_freq : btv->tv_freq;
1863
1864 return 0;
1865}
1866
1867static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f)
1868{
1869 struct v4l2_frequency new_freq = *f;
1870
1871 bttv_call_all(btv, tuner, s_frequency, f);
1872
1873
1874 bttv_call_all(btv, tuner, g_frequency, &new_freq);
1875 if (new_freq.type == V4L2_TUNER_RADIO) {
1876 radio_enable(btv);
1877 btv->radio_freq = new_freq.frequency;
1878 if (btv->has_matchbox)
1879 tea5757_set_freq(btv, btv->radio_freq);
1880 } else {
1881 btv->tv_freq = new_freq.frequency;
1882 }
1883}
1884
1885static int bttv_s_frequency(struct file *file, void *priv,
1886 const struct v4l2_frequency *f)
1887{
1888 struct bttv_fh *fh = priv;
1889 struct bttv *btv = fh->btv;
1890
1891 if (f->tuner)
1892 return -EINVAL;
1893
1894 bttv_set_frequency(btv, f);
1895 return 0;
1896}
1897
1898static int bttv_log_status(struct file *file, void *f)
1899{
1900 struct video_device *vdev = video_devdata(file);
1901 struct bttv_fh *fh = f;
1902 struct bttv *btv = fh->btv;
1903
1904 v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name);
1905 bttv_call_all(btv, core, log_status);
1906 return 0;
1907}
1908
1909#ifdef CONFIG_VIDEO_ADV_DEBUG
1910static int bttv_g_register(struct file *file, void *f,
1911 struct v4l2_dbg_register *reg)
1912{
1913 struct bttv_fh *fh = f;
1914 struct bttv *btv = fh->btv;
1915
1916
1917 reg->reg &= 0xfff;
1918 reg->val = btread(reg->reg);
1919 reg->size = 1;
1920
1921 return 0;
1922}
1923
1924static int bttv_s_register(struct file *file, void *f,
1925 const struct v4l2_dbg_register *reg)
1926{
1927 struct bttv_fh *fh = f;
1928 struct bttv *btv = fh->btv;
1929
1930
1931 btwrite(reg->val, reg->reg & 0xfff);
1932
1933 return 0;
1934}
1935#endif
1936
1937
1938
1939
1940static void
1941bttv_crop_adjust (struct bttv_crop * c,
1942 const struct v4l2_rect * b,
1943 __s32 width,
1944 __s32 height,
1945 enum v4l2_field field)
1946{
1947 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
1948 __s32 max_left;
1949 __s32 max_top;
1950
1951 if (width < c->min_scaled_width) {
1952
1953 c->rect.width = width * 16;
1954 } else if (width > c->max_scaled_width) {
1955
1956 c->rect.width = width;
1957
1958 max_left = b->left + b->width - width;
1959 max_left = min(max_left, (__s32) MAX_HDELAY);
1960 if (c->rect.left > max_left)
1961 c->rect.left = max_left;
1962 }
1963
1964 if (height < c->min_scaled_height) {
1965
1966 c->rect.height = height * 16;
1967 } else if (frame_height > c->max_scaled_height) {
1968
1969
1970 c->rect.height = (frame_height + 1) & ~1;
1971
1972 max_top = b->top + b->height - c->rect.height;
1973 if (c->rect.top > max_top)
1974 c->rect.top = max_top;
1975 }
1976
1977 bttv_crop_calc_limits(c);
1978}
1979
1980
1981
1982
1983
1984
1985
1986
1987static int
1988limit_scaled_size_lock (struct bttv_fh * fh,
1989 __s32 * width,
1990 __s32 * height,
1991 enum v4l2_field field,
1992 unsigned int width_mask,
1993 unsigned int width_bias,
1994 int adjust_size,
1995 int adjust_crop)
1996{
1997 struct bttv *btv = fh->btv;
1998 const struct v4l2_rect *b;
1999 struct bttv_crop *c;
2000 __s32 min_width;
2001 __s32 min_height;
2002 __s32 max_width;
2003 __s32 max_height;
2004 int rc;
2005
2006 BUG_ON((int) width_mask >= 0 ||
2007 width_bias >= (unsigned int) -width_mask);
2008
2009
2010
2011
2012 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2013
2014
2015 c = &btv->crop[!!fh->do_crop];
2016
2017 if (fh->do_crop
2018 && adjust_size
2019 && adjust_crop
2020 && !locked_btres(btv, VIDEO_RESOURCES)) {
2021 min_width = 48;
2022 min_height = 32;
2023
2024
2025
2026
2027 max_width = min(b->width, (__s32) MAX_HACTIVE);
2028 max_height = b->height;
2029
2030
2031
2032
2033 if (btv->vbi_end > b->top) {
2034 max_height -= btv->vbi_end - b->top;
2035 rc = -EBUSY;
2036 if (min_height > max_height)
2037 goto fail;
2038 }
2039 } else {
2040 rc = -EBUSY;
2041 if (btv->vbi_end > c->rect.top)
2042 goto fail;
2043
2044 min_width = c->min_scaled_width;
2045 min_height = c->min_scaled_height;
2046 max_width = c->max_scaled_width;
2047 max_height = c->max_scaled_height;
2048
2049 adjust_crop = 0;
2050 }
2051
2052 min_width = (min_width - width_mask - 1) & width_mask;
2053 max_width = max_width & width_mask;
2054
2055
2056 min_height = min_height;
2057
2058 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2059
2060 if (adjust_size) {
2061 *width = clamp(*width, min_width, max_width);
2062 *height = clamp(*height, min_height, max_height);
2063
2064
2065 *width = (*width + width_bias) & width_mask;
2066
2067 if (adjust_crop) {
2068 bttv_crop_adjust(c, b, *width, *height, field);
2069
2070 if (btv->vbi_end > c->rect.top) {
2071
2072 c->rect.top = btv->vbi_end;
2073 }
2074 }
2075 } else {
2076 rc = -EINVAL;
2077 if (*width < min_width ||
2078 *height < min_height ||
2079 *width > max_width ||
2080 *height > max_height ||
2081 0 != (*width & ~width_mask))
2082 goto fail;
2083 }
2084
2085 rc = 0;
2086
2087 fail:
2088
2089 return rc;
2090}
2091
2092
2093
2094
2095
2096
2097
2098
2099static int
2100verify_window_lock(struct bttv_fh *fh, struct v4l2_window *win,
2101 int adjust_size, int adjust_crop)
2102{
2103 enum v4l2_field field;
2104 unsigned int width_mask;
2105 int rc;
2106
2107 if (win->w.width < 48)
2108 win->w.width = 48;
2109 if (win->w.height < 32)
2110 win->w.height = 32;
2111 if (win->clipcount > 2048)
2112 win->clipcount = 2048;
2113
2114 win->chromakey = 0;
2115 win->global_alpha = 0;
2116 field = win->field;
2117
2118 switch (field) {
2119 case V4L2_FIELD_TOP:
2120 case V4L2_FIELD_BOTTOM:
2121 case V4L2_FIELD_INTERLACED:
2122 break;
2123 default:
2124 field = V4L2_FIELD_ANY;
2125 break;
2126 }
2127 if (V4L2_FIELD_ANY == field) {
2128 __s32 height2;
2129
2130 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2131 field = (win->w.height > height2)
2132 ? V4L2_FIELD_INTERLACED
2133 : V4L2_FIELD_TOP;
2134 }
2135 win->field = field;
2136
2137 if (NULL == fh->ovfmt)
2138 return -EINVAL;
2139
2140 width_mask = ~0;
2141 switch (fh->ovfmt->depth) {
2142 case 8:
2143 case 24:
2144 width_mask = ~3;
2145 break;
2146 case 16:
2147 width_mask = ~1;
2148 break;
2149 case 32:
2150 break;
2151 default:
2152 BUG();
2153 }
2154
2155 win->w.width -= win->w.left & ~width_mask;
2156 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2157
2158 rc = limit_scaled_size_lock(fh, &win->w.width, &win->w.height,
2159 field, width_mask,
2160 0,
2161 adjust_size, adjust_crop);
2162 if (0 != rc)
2163 return rc;
2164 return 0;
2165}
2166
2167static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2168 struct v4l2_window *win, int fixup)
2169{
2170 struct v4l2_clip *clips = NULL;
2171 int n,size,retval = 0;
2172
2173 if (NULL == fh->ovfmt)
2174 return -EINVAL;
2175 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2176 return -EINVAL;
2177 retval = verify_window_lock(fh, win,
2178 fixup,
2179 fixup);
2180 if (0 != retval)
2181 return retval;
2182
2183
2184
2185 n = win->clipcount;
2186 size = sizeof(*clips)*(n+4);
2187 clips = kmalloc(size,GFP_KERNEL);
2188 if (NULL == clips)
2189 return -ENOMEM;
2190 if (n > 0) {
2191 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2192 kfree(clips);
2193 return -EFAULT;
2194 }
2195 }
2196
2197
2198 if (NULL != btv->fbuf.base)
2199 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2200 &win->w, clips, n);
2201 btcx_sort_clips(clips,n);
2202
2203
2204 switch (fh->ovfmt->depth) {
2205 case 8:
2206 case 24:
2207 btcx_align(&win->w, clips, n, 3);
2208 break;
2209 case 16:
2210 btcx_align(&win->w, clips, n, 1);
2211 break;
2212 case 32:
2213
2214 break;
2215 default:
2216 BUG();
2217 }
2218
2219 kfree(fh->ov.clips);
2220 fh->ov.clips = clips;
2221 fh->ov.nclips = n;
2222
2223 fh->ov.w = win->w;
2224 fh->ov.field = win->field;
2225 fh->ov.setup_ok = 1;
2226
2227 btv->init.ov.w.width = win->w.width;
2228 btv->init.ov.w.height = win->w.height;
2229 btv->init.ov.field = win->field;
2230
2231
2232 retval = 0;
2233 if (check_btres(fh, RESOURCE_OVERLAY)) {
2234 struct bttv_buffer *new;
2235
2236 new = videobuf_sg_alloc(sizeof(*new));
2237 new->crop = btv->crop[!!fh->do_crop].rect;
2238 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2239 retval = bttv_switch_overlay(btv,fh,new);
2240 }
2241 return retval;
2242}
2243
2244
2245
2246static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2247{
2248 struct videobuf_queue* q = NULL;
2249
2250 switch (fh->type) {
2251 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2252 q = &fh->cap;
2253 break;
2254 case V4L2_BUF_TYPE_VBI_CAPTURE:
2255 q = &fh->vbi;
2256 break;
2257 default:
2258 BUG();
2259 }
2260 return q;
2261}
2262
2263static int bttv_resource(struct bttv_fh *fh)
2264{
2265 int res = 0;
2266
2267 switch (fh->type) {
2268 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2269 res = RESOURCE_VIDEO_STREAM;
2270 break;
2271 case V4L2_BUF_TYPE_VBI_CAPTURE:
2272 res = RESOURCE_VBI;
2273 break;
2274 default:
2275 BUG();
2276 }
2277 return res;
2278}
2279
2280static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2281{
2282 struct videobuf_queue *q = bttv_queue(fh);
2283 int res = bttv_resource(fh);
2284
2285 if (check_btres(fh,res))
2286 return -EBUSY;
2287 if (videobuf_queue_is_busy(q))
2288 return -EBUSY;
2289 fh->type = type;
2290 return 0;
2291}
2292
2293static void
2294pix_format_set_size (struct v4l2_pix_format * f,
2295 const struct bttv_format * fmt,
2296 unsigned int width,
2297 unsigned int height)
2298{
2299 f->width = width;
2300 f->height = height;
2301
2302 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2303 f->bytesperline = width;
2304 f->sizeimage = (width * height * fmt->depth) >> 3;
2305 } else {
2306 f->bytesperline = (width * fmt->depth) >> 3;
2307 f->sizeimage = height * f->bytesperline;
2308 }
2309}
2310
2311static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2312 struct v4l2_format *f)
2313{
2314 struct bttv_fh *fh = priv;
2315
2316 pix_format_set_size(&f->fmt.pix, fh->fmt,
2317 fh->width, fh->height);
2318 f->fmt.pix.field = fh->cap.field;
2319 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2320 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2321
2322 return 0;
2323}
2324
2325static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2326 struct v4l2_format *f)
2327{
2328 struct bttv_fh *fh = priv;
2329
2330 f->fmt.win.w = fh->ov.w;
2331 f->fmt.win.field = fh->ov.field;
2332
2333 return 0;
2334}
2335
2336static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2337 struct v4l2_format *f)
2338{
2339 const struct bttv_format *fmt;
2340 struct bttv_fh *fh = priv;
2341 struct bttv *btv = fh->btv;
2342 enum v4l2_field field;
2343 __s32 width, height;
2344 __s32 height2;
2345 int rc;
2346
2347 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2348 if (NULL == fmt)
2349 return -EINVAL;
2350
2351 field = f->fmt.pix.field;
2352
2353 switch (field) {
2354 case V4L2_FIELD_TOP:
2355 case V4L2_FIELD_BOTTOM:
2356 case V4L2_FIELD_ALTERNATE:
2357 case V4L2_FIELD_INTERLACED:
2358 break;
2359 case V4L2_FIELD_SEQ_BT:
2360 case V4L2_FIELD_SEQ_TB:
2361 if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) {
2362 field = V4L2_FIELD_SEQ_TB;
2363 break;
2364 }
2365
2366 default:
2367 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2368 field = (f->fmt.pix.height > height2)
2369 ? V4L2_FIELD_INTERLACED
2370 : V4L2_FIELD_BOTTOM;
2371 break;
2372 }
2373
2374 width = f->fmt.pix.width;
2375 height = f->fmt.pix.height;
2376
2377 rc = limit_scaled_size_lock(fh, &width, &height, field,
2378 ~3,
2379 2,
2380 1,
2381 0);
2382 if (0 != rc)
2383 return rc;
2384
2385
2386 f->fmt.pix.field = field;
2387 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2388 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2389
2390 return 0;
2391}
2392
2393static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2394 struct v4l2_format *f)
2395{
2396 struct bttv_fh *fh = priv;
2397
2398 verify_window_lock(fh, &f->fmt.win,
2399 1,
2400 0);
2401 return 0;
2402}
2403
2404static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2405 struct v4l2_format *f)
2406{
2407 int retval;
2408 const struct bttv_format *fmt;
2409 struct bttv_fh *fh = priv;
2410 struct bttv *btv = fh->btv;
2411 __s32 width, height;
2412 enum v4l2_field field;
2413
2414 retval = bttv_switch_type(fh, f->type);
2415 if (0 != retval)
2416 return retval;
2417
2418 retval = bttv_try_fmt_vid_cap(file, priv, f);
2419 if (0 != retval)
2420 return retval;
2421
2422 width = f->fmt.pix.width;
2423 height = f->fmt.pix.height;
2424 field = f->fmt.pix.field;
2425
2426 retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field,
2427 ~3,
2428 2,
2429 1,
2430 1);
2431 if (0 != retval)
2432 return retval;
2433
2434 f->fmt.pix.field = field;
2435
2436 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2437
2438
2439 fh->fmt = fmt;
2440 fh->cap.field = f->fmt.pix.field;
2441 fh->cap.last = V4L2_FIELD_NONE;
2442 fh->width = f->fmt.pix.width;
2443 fh->height = f->fmt.pix.height;
2444 btv->init.fmt = fmt;
2445 btv->init.width = f->fmt.pix.width;
2446 btv->init.height = f->fmt.pix.height;
2447
2448 return 0;
2449}
2450
2451static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2452 struct v4l2_format *f)
2453{
2454 struct bttv_fh *fh = priv;
2455 struct bttv *btv = fh->btv;
2456
2457 if (no_overlay > 0) {
2458 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2459 return -EINVAL;
2460 }
2461
2462 return setup_window_lock(fh, btv, &f->fmt.win, 1);
2463}
2464
2465static int bttv_querycap(struct file *file, void *priv,
2466 struct v4l2_capability *cap)
2467{
2468 struct video_device *vdev = video_devdata(file);
2469 struct bttv_fh *fh = priv;
2470 struct bttv *btv = fh->btv;
2471
2472 if (0 == v4l2)
2473 return -EINVAL;
2474
2475 strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2476 strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2477 snprintf(cap->bus_info, sizeof(cap->bus_info),
2478 "PCI:%s", pci_name(btv->c.pci));
2479 cap->capabilities =
2480 V4L2_CAP_VIDEO_CAPTURE |
2481 V4L2_CAP_READWRITE |
2482 V4L2_CAP_STREAMING |
2483 V4L2_CAP_DEVICE_CAPS;
2484 if (no_overlay <= 0)
2485 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2486 if (btv->vbi_dev)
2487 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
2488 if (btv->radio_dev)
2489 cap->capabilities |= V4L2_CAP_RADIO;
2490
2491
2492
2493
2494
2495 if (btv->has_saa6588)
2496 cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2497 if (btv->tuner_type != TUNER_ABSENT)
2498 cap->capabilities |= V4L2_CAP_TUNER;
2499 if (vdev->vfl_type == VFL_TYPE_GRABBER)
2500 cap->device_caps = cap->capabilities &
2501 (V4L2_CAP_VIDEO_CAPTURE |
2502 V4L2_CAP_READWRITE |
2503 V4L2_CAP_STREAMING |
2504 V4L2_CAP_VIDEO_OVERLAY |
2505 V4L2_CAP_TUNER);
2506 else if (vdev->vfl_type == VFL_TYPE_VBI)
2507 cap->device_caps = cap->capabilities &
2508 (V4L2_CAP_VBI_CAPTURE |
2509 V4L2_CAP_READWRITE |
2510 V4L2_CAP_STREAMING |
2511 V4L2_CAP_TUNER);
2512 else {
2513 cap->device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
2514 if (btv->has_saa6588)
2515 cap->device_caps |= V4L2_CAP_READWRITE |
2516 V4L2_CAP_RDS_CAPTURE;
2517 }
2518 return 0;
2519}
2520
2521static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2522{
2523 int index = -1, i;
2524
2525 for (i = 0; i < FORMATS; i++) {
2526 if (formats[i].fourcc != -1)
2527 index++;
2528 if ((unsigned int)index == f->index)
2529 break;
2530 }
2531 if (FORMATS == i)
2532 return -EINVAL;
2533
2534 f->pixelformat = formats[i].fourcc;
2535 strlcpy(f->description, formats[i].name, sizeof(f->description));
2536
2537 return i;
2538}
2539
2540static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
2541 struct v4l2_fmtdesc *f)
2542{
2543 int rc = bttv_enum_fmt_cap_ovr(f);
2544
2545 if (rc < 0)
2546 return rc;
2547
2548 return 0;
2549}
2550
2551static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv,
2552 struct v4l2_fmtdesc *f)
2553{
2554 int rc;
2555
2556 if (no_overlay > 0) {
2557 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2558 return -EINVAL;
2559 }
2560
2561 rc = bttv_enum_fmt_cap_ovr(f);
2562
2563 if (rc < 0)
2564 return rc;
2565
2566 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2567 return -EINVAL;
2568
2569 return 0;
2570}
2571
2572static int bttv_g_fbuf(struct file *file, void *f,
2573 struct v4l2_framebuffer *fb)
2574{
2575 struct bttv_fh *fh = f;
2576 struct bttv *btv = fh->btv;
2577
2578 *fb = btv->fbuf;
2579 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2580 fb->flags = V4L2_FBUF_FLAG_PRIMARY;
2581 if (fh->ovfmt)
2582 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2583 return 0;
2584}
2585
2586static int bttv_overlay(struct file *file, void *f, unsigned int on)
2587{
2588 struct bttv_fh *fh = f;
2589 struct bttv *btv = fh->btv;
2590 struct bttv_buffer *new;
2591 int retval = 0;
2592
2593 if (on) {
2594
2595 if (unlikely(!btv->fbuf.base)) {
2596 return -EINVAL;
2597 }
2598 if (unlikely(!fh->ov.setup_ok)) {
2599 dprintk("%d: overlay: !setup_ok\n", btv->c.nr);
2600 retval = -EINVAL;
2601 }
2602 if (retval)
2603 return retval;
2604 }
2605
2606 if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
2607 return -EBUSY;
2608
2609 if (on) {
2610 fh->ov.tvnorm = btv->tvnorm;
2611 new = videobuf_sg_alloc(sizeof(*new));
2612 new->crop = btv->crop[!!fh->do_crop].rect;
2613 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2614 } else {
2615 new = NULL;
2616 }
2617
2618
2619 retval = bttv_switch_overlay(btv, fh, new);
2620 return retval;
2621}
2622
2623static int bttv_s_fbuf(struct file *file, void *f,
2624 const struct v4l2_framebuffer *fb)
2625{
2626 struct bttv_fh *fh = f;
2627 struct bttv *btv = fh->btv;
2628 const struct bttv_format *fmt;
2629 int retval;
2630
2631 if (!capable(CAP_SYS_ADMIN) &&
2632 !capable(CAP_SYS_RAWIO))
2633 return -EPERM;
2634
2635
2636 fmt = format_by_fourcc(fb->fmt.pixelformat);
2637 if (NULL == fmt)
2638 return -EINVAL;
2639 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2640 return -EINVAL;
2641
2642 retval = -EINVAL;
2643 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2644 __s32 width = fb->fmt.width;
2645 __s32 height = fb->fmt.height;
2646
2647 retval = limit_scaled_size_lock(fh, &width, &height,
2648 V4L2_FIELD_INTERLACED,
2649 ~3,
2650 2,
2651 0,
2652 0);
2653 if (0 != retval)
2654 return retval;
2655 }
2656
2657
2658 btv->fbuf.base = fb->base;
2659 btv->fbuf.fmt.width = fb->fmt.width;
2660 btv->fbuf.fmt.height = fb->fmt.height;
2661 if (0 != fb->fmt.bytesperline)
2662 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2663 else
2664 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2665
2666 retval = 0;
2667 fh->ovfmt = fmt;
2668 btv->init.ovfmt = fmt;
2669 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2670 fh->ov.w.left = 0;
2671 fh->ov.w.top = 0;
2672 fh->ov.w.width = fb->fmt.width;
2673 fh->ov.w.height = fb->fmt.height;
2674 btv->init.ov.w.width = fb->fmt.width;
2675 btv->init.ov.w.height = fb->fmt.height;
2676 kfree(fh->ov.clips);
2677 fh->ov.clips = NULL;
2678 fh->ov.nclips = 0;
2679
2680 if (check_btres(fh, RESOURCE_OVERLAY)) {
2681 struct bttv_buffer *new;
2682
2683 new = videobuf_sg_alloc(sizeof(*new));
2684 new->crop = btv->crop[!!fh->do_crop].rect;
2685 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2686 retval = bttv_switch_overlay(btv, fh, new);
2687 }
2688 }
2689 return retval;
2690}
2691
2692static int bttv_reqbufs(struct file *file, void *priv,
2693 struct v4l2_requestbuffers *p)
2694{
2695 struct bttv_fh *fh = priv;
2696 return videobuf_reqbufs(bttv_queue(fh), p);
2697}
2698
2699static int bttv_querybuf(struct file *file, void *priv,
2700 struct v4l2_buffer *b)
2701{
2702 struct bttv_fh *fh = priv;
2703 return videobuf_querybuf(bttv_queue(fh), b);
2704}
2705
2706static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2707{
2708 struct bttv_fh *fh = priv;
2709 struct bttv *btv = fh->btv;
2710 int res = bttv_resource(fh);
2711
2712 if (!check_alloc_btres_lock(btv, fh, res))
2713 return -EBUSY;
2714
2715 return videobuf_qbuf(bttv_queue(fh), b);
2716}
2717
2718static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2719{
2720 struct bttv_fh *fh = priv;
2721 return videobuf_dqbuf(bttv_queue(fh), b,
2722 file->f_flags & O_NONBLOCK);
2723}
2724
2725static int bttv_streamon(struct file *file, void *priv,
2726 enum v4l2_buf_type type)
2727{
2728 struct bttv_fh *fh = priv;
2729 struct bttv *btv = fh->btv;
2730 int res = bttv_resource(fh);
2731
2732 if (!check_alloc_btres_lock(btv, fh, res))
2733 return -EBUSY;
2734 return videobuf_streamon(bttv_queue(fh));
2735}
2736
2737
2738static int bttv_streamoff(struct file *file, void *priv,
2739 enum v4l2_buf_type type)
2740{
2741 struct bttv_fh *fh = priv;
2742 struct bttv *btv = fh->btv;
2743 int retval;
2744 int res = bttv_resource(fh);
2745
2746
2747 retval = videobuf_streamoff(bttv_queue(fh));
2748 if (retval < 0)
2749 return retval;
2750 free_btres_lock(btv, fh, res);
2751 return 0;
2752}
2753
2754static int bttv_g_parm(struct file *file, void *f,
2755 struct v4l2_streamparm *parm)
2756{
2757 struct bttv_fh *fh = f;
2758 struct bttv *btv = fh->btv;
2759
2760 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2761 return -EINVAL;
2762 parm->parm.capture.readbuffers = gbuffers;
2763 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2764 &parm->parm.capture.timeperframe);
2765
2766 return 0;
2767}
2768
2769static int bttv_g_tuner(struct file *file, void *priv,
2770 struct v4l2_tuner *t)
2771{
2772 struct bttv_fh *fh = priv;
2773 struct bttv *btv = fh->btv;
2774
2775 if (0 != t->index)
2776 return -EINVAL;
2777
2778 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2779 t->capability = V4L2_TUNER_CAP_NORM;
2780 bttv_call_all(btv, tuner, g_tuner, t);
2781 strcpy(t->name, "Television");
2782 t->type = V4L2_TUNER_ANALOG_TV;
2783 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2784 t->signal = 0xffff;
2785
2786 if (btv->audio_mode_gpio)
2787 btv->audio_mode_gpio(btv, t, 0);
2788
2789 return 0;
2790}
2791
2792static int bttv_cropcap(struct file *file, void *priv,
2793 struct v4l2_cropcap *cap)
2794{
2795 struct bttv_fh *fh = priv;
2796 struct bttv *btv = fh->btv;
2797
2798 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2799 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2800 return -EINVAL;
2801
2802 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
2803
2804 return 0;
2805}
2806
2807static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
2808{
2809 struct bttv_fh *fh = f;
2810 struct bttv *btv = fh->btv;
2811
2812 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2813 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2814 return -EINVAL;
2815
2816
2817
2818
2819
2820 crop->c = btv->crop[!!fh->do_crop].rect;
2821
2822 return 0;
2823}
2824
2825static int bttv_s_crop(struct file *file, void *f, const struct v4l2_crop *crop)
2826{
2827 struct bttv_fh *fh = f;
2828 struct bttv *btv = fh->btv;
2829 const struct v4l2_rect *b;
2830 int retval;
2831 struct bttv_crop c;
2832 __s32 b_left;
2833 __s32 b_top;
2834 __s32 b_right;
2835 __s32 b_bottom;
2836
2837 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2838 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2839 return -EINVAL;
2840
2841
2842
2843
2844 retval = -EBUSY;
2845
2846 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
2847 return retval;
2848 }
2849
2850 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2851
2852 b_left = b->left;
2853 b_right = b_left + b->width;
2854 b_bottom = b->top + b->height;
2855
2856 b_top = max(b->top, btv->vbi_end);
2857 if (b_top + 32 >= b_bottom) {
2858 return retval;
2859 }
2860
2861
2862 c.rect.left = clamp_t(s32, crop->c.left, b_left, b_right - 48);
2863 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
2864
2865 c.rect.width = clamp_t(s32, crop->c.width,
2866 48, b_right - c.rect.left);
2867
2868 c.rect.top = clamp_t(s32, crop->c.top, b_top, b_bottom - 32);
2869
2870 c.rect.top = (c.rect.top + 1) & ~1;
2871
2872 c.rect.height = clamp_t(s32, crop->c.height,
2873 32, b_bottom - c.rect.top);
2874 c.rect.height = (c.rect.height + 1) & ~1;
2875
2876 bttv_crop_calc_limits(&c);
2877
2878 btv->crop[1] = c;
2879
2880 fh->do_crop = 1;
2881
2882 if (fh->width < c.min_scaled_width) {
2883 fh->width = c.min_scaled_width;
2884 btv->init.width = c.min_scaled_width;
2885 } else if (fh->width > c.max_scaled_width) {
2886 fh->width = c.max_scaled_width;
2887 btv->init.width = c.max_scaled_width;
2888 }
2889
2890 if (fh->height < c.min_scaled_height) {
2891 fh->height = c.min_scaled_height;
2892 btv->init.height = c.min_scaled_height;
2893 } else if (fh->height > c.max_scaled_height) {
2894 fh->height = c.max_scaled_height;
2895 btv->init.height = c.max_scaled_height;
2896 }
2897
2898 return 0;
2899}
2900
2901static ssize_t bttv_read(struct file *file, char __user *data,
2902 size_t count, loff_t *ppos)
2903{
2904 struct bttv_fh *fh = file->private_data;
2905 int retval = 0;
2906
2907 if (fh->btv->errors)
2908 bttv_reinit_bt848(fh->btv);
2909 dprintk("%d: read count=%d type=%s\n",
2910 fh->btv->c.nr, (int)count, v4l2_type_names[fh->type]);
2911
2912 switch (fh->type) {
2913 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2914 if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) {
2915
2916
2917 return -EBUSY;
2918 }
2919 retval = videobuf_read_one(&fh->cap, data, count, ppos,
2920 file->f_flags & O_NONBLOCK);
2921 free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ);
2922 break;
2923 case V4L2_BUF_TYPE_VBI_CAPTURE:
2924 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
2925 return -EBUSY;
2926 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2927 file->f_flags & O_NONBLOCK);
2928 break;
2929 default:
2930 BUG();
2931 }
2932 return retval;
2933}
2934
2935static unsigned int bttv_poll(struct file *file, poll_table *wait)
2936{
2937 struct bttv_fh *fh = file->private_data;
2938 struct bttv_buffer *buf;
2939 enum v4l2_field field;
2940 unsigned int rc = 0;
2941 unsigned long req_events = poll_requested_events(wait);
2942
2943 if (v4l2_event_pending(&fh->fh))
2944 rc = POLLPRI;
2945 else if (req_events & POLLPRI)
2946 poll_wait(file, &fh->fh.wait, wait);
2947
2948 if (!(req_events & (POLLIN | POLLRDNORM)))
2949 return rc;
2950
2951 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2952 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
2953 return rc | POLLERR;
2954 return rc | videobuf_poll_stream(file, &fh->vbi, wait);
2955 }
2956
2957 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
2958
2959 if (list_empty(&fh->cap.stream))
2960 return rc | POLLERR;
2961 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
2962 } else {
2963
2964 if (NULL == fh->cap.read_buf) {
2965
2966 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
2967 return rc | POLLERR;
2968 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
2969 if (NULL == fh->cap.read_buf)
2970 return rc | POLLERR;
2971 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
2972 field = videobuf_next_field(&fh->cap);
2973 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
2974 kfree (fh->cap.read_buf);
2975 fh->cap.read_buf = NULL;
2976 return rc | POLLERR;
2977 }
2978 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
2979 fh->cap.read_off = 0;
2980 }
2981 buf = (struct bttv_buffer*)fh->cap.read_buf;
2982 }
2983
2984 poll_wait(file, &buf->vb.done, wait);
2985 if (buf->vb.state == VIDEOBUF_DONE ||
2986 buf->vb.state == VIDEOBUF_ERROR)
2987 rc = rc | POLLIN|POLLRDNORM;
2988 return rc;
2989}
2990
2991static int bttv_open(struct file *file)
2992{
2993 struct video_device *vdev = video_devdata(file);
2994 struct bttv *btv = video_drvdata(file);
2995 struct bttv_fh *fh;
2996 enum v4l2_buf_type type = 0;
2997
2998 dprintk("open dev=%s\n", video_device_node_name(vdev));
2999
3000 if (vdev->vfl_type == VFL_TYPE_GRABBER) {
3001 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3002 } else if (vdev->vfl_type == VFL_TYPE_VBI) {
3003 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3004 } else {
3005 WARN_ON(1);
3006 return -ENODEV;
3007 }
3008
3009 dprintk("%d: open called (type=%s)\n",
3010 btv->c.nr, v4l2_type_names[type]);
3011
3012
3013 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3014 if (unlikely(!fh))
3015 return -ENOMEM;
3016 btv->users++;
3017 file->private_data = fh;
3018
3019 *fh = btv->init;
3020 v4l2_fh_init(&fh->fh, vdev);
3021
3022 fh->type = type;
3023 fh->ov.setup_ok = 0;
3024
3025 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3026 &btv->c.pci->dev, &btv->s_lock,
3027 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3028 V4L2_FIELD_INTERLACED,
3029 sizeof(struct bttv_buffer),
3030 fh, &btv->lock);
3031 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3032 &btv->c.pci->dev, &btv->s_lock,
3033 V4L2_BUF_TYPE_VBI_CAPTURE,
3034 V4L2_FIELD_SEQ_TB,
3035 sizeof(struct bttv_buffer),
3036 fh, &btv->lock);
3037 set_tvnorm(btv,btv->tvnorm);
3038 set_input(btv, btv->input, btv->tvnorm);
3039 audio_mute(btv, btv->mute);
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050 fh->do_crop = !reset_crop;
3051
3052
3053
3054
3055 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3056
3057 bttv_field_count(btv);
3058 v4l2_fh_add(&fh->fh);
3059 return 0;
3060}
3061
3062static int bttv_release(struct file *file)
3063{
3064 struct bttv_fh *fh = file->private_data;
3065 struct bttv *btv = fh->btv;
3066
3067
3068 if (check_btres(fh, RESOURCE_OVERLAY))
3069 bttv_switch_overlay(btv,fh,NULL);
3070
3071
3072 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3073 videobuf_streamoff(&fh->cap);
3074 free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM);
3075 }
3076 if (fh->cap.read_buf) {
3077 buffer_release(&fh->cap,fh->cap.read_buf);
3078 kfree(fh->cap.read_buf);
3079 }
3080 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3081 free_btres_lock(btv, fh, RESOURCE_VIDEO_READ);
3082 }
3083
3084
3085 if (check_btres(fh, RESOURCE_VBI)) {
3086 videobuf_stop(&fh->vbi);
3087 free_btres_lock(btv,fh,RESOURCE_VBI);
3088 }
3089
3090
3091
3092 videobuf_mmap_free(&fh->cap);
3093 videobuf_mmap_free(&fh->vbi);
3094 file->private_data = NULL;
3095
3096 btv->users--;
3097 bttv_field_count(btv);
3098
3099 if (!btv->users)
3100 audio_mute(btv, btv->mute);
3101
3102 v4l2_fh_del(&fh->fh);
3103 v4l2_fh_exit(&fh->fh);
3104 kfree(fh);
3105 return 0;
3106}
3107
3108static int
3109bttv_mmap(struct file *file, struct vm_area_struct *vma)
3110{
3111 struct bttv_fh *fh = file->private_data;
3112
3113 dprintk("%d: mmap type=%s 0x%lx+%ld\n",
3114 fh->btv->c.nr, v4l2_type_names[fh->type],
3115 vma->vm_start, vma->vm_end - vma->vm_start);
3116 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3117}
3118
3119static const struct v4l2_file_operations bttv_fops =
3120{
3121 .owner = THIS_MODULE,
3122 .open = bttv_open,
3123 .release = bttv_release,
3124 .unlocked_ioctl = video_ioctl2,
3125 .read = bttv_read,
3126 .mmap = bttv_mmap,
3127 .poll = bttv_poll,
3128};
3129
3130static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3131 .vidioc_querycap = bttv_querycap,
3132 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
3133 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
3134 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
3135 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
3136 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay,
3137 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay,
3138 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay,
3139 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay,
3140 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
3141 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
3142 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
3143 .vidioc_cropcap = bttv_cropcap,
3144 .vidioc_reqbufs = bttv_reqbufs,
3145 .vidioc_querybuf = bttv_querybuf,
3146 .vidioc_qbuf = bttv_qbuf,
3147 .vidioc_dqbuf = bttv_dqbuf,
3148 .vidioc_s_std = bttv_s_std,
3149 .vidioc_g_std = bttv_g_std,
3150 .vidioc_enum_input = bttv_enum_input,
3151 .vidioc_g_input = bttv_g_input,
3152 .vidioc_s_input = bttv_s_input,
3153 .vidioc_streamon = bttv_streamon,
3154 .vidioc_streamoff = bttv_streamoff,
3155 .vidioc_g_tuner = bttv_g_tuner,
3156 .vidioc_s_tuner = bttv_s_tuner,
3157 .vidioc_g_crop = bttv_g_crop,
3158 .vidioc_s_crop = bttv_s_crop,
3159 .vidioc_g_fbuf = bttv_g_fbuf,
3160 .vidioc_s_fbuf = bttv_s_fbuf,
3161 .vidioc_overlay = bttv_overlay,
3162 .vidioc_g_parm = bttv_g_parm,
3163 .vidioc_g_frequency = bttv_g_frequency,
3164 .vidioc_s_frequency = bttv_s_frequency,
3165 .vidioc_log_status = bttv_log_status,
3166 .vidioc_querystd = bttv_querystd,
3167 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
3168 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
3169#ifdef CONFIG_VIDEO_ADV_DEBUG
3170 .vidioc_g_register = bttv_g_register,
3171 .vidioc_s_register = bttv_s_register,
3172#endif
3173};
3174
3175static struct video_device bttv_video_template = {
3176 .fops = &bttv_fops,
3177 .ioctl_ops = &bttv_ioctl_ops,
3178 .tvnorms = BTTV_NORMS,
3179};
3180
3181
3182
3183
3184static int radio_open(struct file *file)
3185{
3186 struct video_device *vdev = video_devdata(file);
3187 struct bttv *btv = video_drvdata(file);
3188 struct bttv_fh *fh;
3189
3190 dprintk("open dev=%s\n", video_device_node_name(vdev));
3191
3192 dprintk("%d: open called (radio)\n", btv->c.nr);
3193
3194
3195 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3196 if (unlikely(!fh))
3197 return -ENOMEM;
3198 file->private_data = fh;
3199 *fh = btv->init;
3200 v4l2_fh_init(&fh->fh, vdev);
3201
3202 btv->radio_user++;
3203 audio_mute(btv, btv->mute);
3204
3205 v4l2_fh_add(&fh->fh);
3206
3207 return 0;
3208}
3209
3210static int radio_release(struct file *file)
3211{
3212 struct bttv_fh *fh = file->private_data;
3213 struct bttv *btv = fh->btv;
3214 struct saa6588_command cmd;
3215
3216 file->private_data = NULL;
3217 v4l2_fh_del(&fh->fh);
3218 v4l2_fh_exit(&fh->fh);
3219 kfree(fh);
3220
3221 btv->radio_user--;
3222
3223 bttv_call_all(btv, core, ioctl, SAA6588_CMD_CLOSE, &cmd);
3224
3225 if (btv->radio_user == 0)
3226 btv->has_radio_tuner = 0;
3227 return 0;
3228}
3229
3230static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3231{
3232 struct bttv_fh *fh = priv;
3233 struct bttv *btv = fh->btv;
3234
3235 if (0 != t->index)
3236 return -EINVAL;
3237 strcpy(t->name, "Radio");
3238 t->type = V4L2_TUNER_RADIO;
3239 radio_enable(btv);
3240
3241 bttv_call_all(btv, tuner, g_tuner, t);
3242
3243 if (btv->audio_mode_gpio)
3244 btv->audio_mode_gpio(btv, t, 0);
3245
3246 return 0;
3247}
3248
3249static int radio_s_tuner(struct file *file, void *priv,
3250 const struct v4l2_tuner *t)
3251{
3252 struct bttv_fh *fh = priv;
3253 struct bttv *btv = fh->btv;
3254
3255 if (0 != t->index)
3256 return -EINVAL;
3257
3258 radio_enable(btv);
3259 bttv_call_all(btv, tuner, s_tuner, t);
3260 return 0;
3261}
3262
3263static ssize_t radio_read(struct file *file, char __user *data,
3264 size_t count, loff_t *ppos)
3265{
3266 struct bttv_fh *fh = file->private_data;
3267 struct bttv *btv = fh->btv;
3268 struct saa6588_command cmd;
3269 cmd.block_count = count/3;
3270 cmd.buffer = data;
3271 cmd.instance = file;
3272 cmd.result = -ENODEV;
3273 radio_enable(btv);
3274
3275 bttv_call_all(btv, core, ioctl, SAA6588_CMD_READ, &cmd);
3276
3277 return cmd.result;
3278}
3279
3280static unsigned int radio_poll(struct file *file, poll_table *wait)
3281{
3282 struct bttv_fh *fh = file->private_data;
3283 struct bttv *btv = fh->btv;
3284 unsigned long req_events = poll_requested_events(wait);
3285 struct saa6588_command cmd;
3286 unsigned int res = 0;
3287
3288 if (v4l2_event_pending(&fh->fh))
3289 res = POLLPRI;
3290 else if (req_events & POLLPRI)
3291 poll_wait(file, &fh->fh.wait, wait);
3292 radio_enable(btv);
3293 cmd.instance = file;
3294 cmd.event_list = wait;
3295 cmd.result = res;
3296 bttv_call_all(btv, core, ioctl, SAA6588_CMD_POLL, &cmd);
3297
3298 return cmd.result;
3299}
3300
3301static const struct v4l2_file_operations radio_fops =
3302{
3303 .owner = THIS_MODULE,
3304 .open = radio_open,
3305 .read = radio_read,
3306 .release = radio_release,
3307 .unlocked_ioctl = video_ioctl2,
3308 .poll = radio_poll,
3309};
3310
3311static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3312 .vidioc_querycap = bttv_querycap,
3313 .vidioc_log_status = bttv_log_status,
3314 .vidioc_g_tuner = radio_g_tuner,
3315 .vidioc_s_tuner = radio_s_tuner,
3316 .vidioc_g_frequency = bttv_g_frequency,
3317 .vidioc_s_frequency = bttv_s_frequency,
3318 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
3319 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
3320};
3321
3322static struct video_device radio_template = {
3323 .fops = &radio_fops,
3324 .ioctl_ops = &radio_ioctl_ops,
3325};
3326
3327
3328
3329
3330static int bttv_risc_decode(u32 risc)
3331{
3332 static char *instr[16] = {
3333 [ BT848_RISC_WRITE >> 28 ] = "write",
3334 [ BT848_RISC_SKIP >> 28 ] = "skip",
3335 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3336 [ BT848_RISC_JUMP >> 28 ] = "jump",
3337 [ BT848_RISC_SYNC >> 28 ] = "sync",
3338 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3339 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3340 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3341 };
3342 static int incr[16] = {
3343 [ BT848_RISC_WRITE >> 28 ] = 2,
3344 [ BT848_RISC_JUMP >> 28 ] = 2,
3345 [ BT848_RISC_SYNC >> 28 ] = 2,
3346 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3347 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3348 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3349 };
3350 static char *bits[] = {
3351 "be0", "be1", "be2", "be3/resync",
3352 "set0", "set1", "set2", "set3",
3353 "clr0", "clr1", "clr2", "clr3",
3354 "irq", "res", "eol", "sol",
3355 };
3356 int i;
3357
3358 pr_cont("0x%08x [ %s", risc,
3359 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3360 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3361 if (risc & (1 << (i + 12)))
3362 pr_cont(" %s", bits[i]);
3363 pr_cont(" count=%d ]\n", risc & 0xfff);
3364 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3365}
3366
3367static void bttv_risc_disasm(struct bttv *btv,
3368 struct btcx_riscmem *risc)
3369{
3370 unsigned int i,j,n;
3371
3372 pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
3373 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3374 for (i = 0; i < (risc->size >> 2); i += n) {
3375 pr_info("%s: 0x%lx: ",
3376 btv->c.v4l2_dev.name,
3377 (unsigned long)(risc->dma + (i<<2)));
3378 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3379 for (j = 1; j < n; j++)
3380 pr_info("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3381 btv->c.v4l2_dev.name,
3382 (unsigned long)(risc->dma + ((i+j)<<2)),
3383 risc->cpu[i+j], j);
3384 if (0 == risc->cpu[i])
3385 break;
3386 }
3387}
3388
3389static void bttv_print_riscaddr(struct bttv *btv)
3390{
3391 pr_info(" main: %08llx\n", (unsigned long long)btv->main.dma);
3392 pr_info(" vbi : o=%08llx e=%08llx\n",
3393 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3394 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3395 pr_info(" cap : o=%08llx e=%08llx\n",
3396 btv->curr.top
3397 ? (unsigned long long)btv->curr.top->top.dma : 0,
3398 btv->curr.bottom
3399 ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3400 pr_info(" scr : o=%08llx e=%08llx\n",
3401 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3402 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3403 bttv_risc_disasm(btv, &btv->main);
3404}
3405
3406
3407
3408
3409static char *irq_name[] = {
3410 "FMTCHG",
3411 "VSYNC",
3412 "HSYNC",
3413 "OFLOW",
3414 "HLOCK",
3415 "VPRES",
3416 "6", "7",
3417 "I2CDONE",
3418 "GPINT",
3419 "10",
3420 "RISCI",
3421 "FBUS",
3422 "FTRGT",
3423 "FDSR",
3424 "PPERR",
3425 "RIPERR",
3426 "PABORT",
3427 "OCERR",
3428 "SCERR",
3429};
3430
3431static void bttv_print_irqbits(u32 print, u32 mark)
3432{
3433 unsigned int i;
3434
3435 pr_cont("bits:");
3436 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3437 if (print & (1 << i))
3438 pr_cont(" %s", irq_name[i]);
3439 if (mark & (1 << i))
3440 pr_cont("*");
3441 }
3442}
3443
3444static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3445{
3446 pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3447 btv->c.nr,
3448 (unsigned long)btv->main.dma,
3449 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3450 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3451 (unsigned long)rc);
3452
3453 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3454 pr_notice("%d: Oh, there (temporarily?) is no input signal. "
3455 "Ok, then this is harmless, don't worry ;)\n",
3456 btv->c.nr);
3457 return;
3458 }
3459 pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n",
3460 btv->c.nr);
3461 pr_notice("%d: Lets try to catch the culpit red-handed ...\n",
3462 btv->c.nr);
3463 dump_stack();
3464}
3465
3466static int
3467bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3468{
3469 struct bttv_buffer *item;
3470
3471 memset(set,0,sizeof(*set));
3472
3473
3474 if (!list_empty(&btv->capture)) {
3475 set->frame_irq = 1;
3476 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3477 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3478 set->top = item;
3479 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3480 set->bottom = item;
3481
3482
3483 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3484 (item->vb.queue.next != &btv->capture)) {
3485 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3514 if (NULL == set->bottom &&
3515 V4L2_FIELD_BOTTOM == item->vb.field) {
3516 set->bottom = item;
3517 }
3518 if (NULL != set->top && NULL != set->bottom)
3519 set->top_irq = 2;
3520 }
3521 }
3522 }
3523
3524
3525 if (NULL != btv->screen) {
3526 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3527 if (NULL == set->top && NULL == set->bottom) {
3528 set->top = btv->screen;
3529 set->bottom = btv->screen;
3530 }
3531 } else {
3532 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3533 NULL == set->top) {
3534 set->top = btv->screen;
3535 }
3536 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3537 NULL == set->bottom) {
3538 set->bottom = btv->screen;
3539 }
3540 }
3541 }
3542
3543 dprintk("%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3544 btv->c.nr, set->top, set->bottom,
3545 btv->screen, set->frame_irq, set->top_irq);
3546 return 0;
3547}
3548
3549static void
3550bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3551 struct bttv_buffer_set *curr, unsigned int state)
3552{
3553 struct timeval ts;
3554
3555 v4l2_get_timestamp(&ts);
3556
3557 if (wakeup->top == wakeup->bottom) {
3558 if (NULL != wakeup->top && curr->top != wakeup->top) {
3559 if (irq_debug > 1)
3560 pr_debug("%d: wakeup: both=%p\n",
3561 btv->c.nr, wakeup->top);
3562 wakeup->top->vb.ts = ts;
3563 wakeup->top->vb.field_count = btv->field_count;
3564 wakeup->top->vb.state = state;
3565 wake_up(&wakeup->top->vb.done);
3566 }
3567 } else {
3568 if (NULL != wakeup->top && curr->top != wakeup->top) {
3569 if (irq_debug > 1)
3570 pr_debug("%d: wakeup: top=%p\n",
3571 btv->c.nr, wakeup->top);
3572 wakeup->top->vb.ts = ts;
3573 wakeup->top->vb.field_count = btv->field_count;
3574 wakeup->top->vb.state = state;
3575 wake_up(&wakeup->top->vb.done);
3576 }
3577 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3578 if (irq_debug > 1)
3579 pr_debug("%d: wakeup: bottom=%p\n",
3580 btv->c.nr, wakeup->bottom);
3581 wakeup->bottom->vb.ts = ts;
3582 wakeup->bottom->vb.field_count = btv->field_count;
3583 wakeup->bottom->vb.state = state;
3584 wake_up(&wakeup->bottom->vb.done);
3585 }
3586 }
3587}
3588
3589static void
3590bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3591 unsigned int state)
3592{
3593 struct timeval ts;
3594
3595 if (NULL == wakeup)
3596 return;
3597
3598 v4l2_get_timestamp(&ts);
3599 wakeup->vb.ts = ts;
3600 wakeup->vb.field_count = btv->field_count;
3601 wakeup->vb.state = state;
3602 wake_up(&wakeup->vb.done);
3603}
3604
3605static void bttv_irq_timeout(unsigned long data)
3606{
3607 struct bttv *btv = (struct bttv *)data;
3608 struct bttv_buffer_set old,new;
3609 struct bttv_buffer *ovbi;
3610 struct bttv_buffer *item;
3611 unsigned long flags;
3612
3613 if (bttv_verbose) {
3614 pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3615 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3616 btread(BT848_RISC_COUNT));
3617 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3618 pr_cont("\n");
3619 }
3620
3621 spin_lock_irqsave(&btv->s_lock,flags);
3622
3623
3624 memset(&new,0,sizeof(new));
3625 old = btv->curr;
3626 ovbi = btv->cvbi;
3627 btv->curr = new;
3628 btv->cvbi = NULL;
3629 btv->loop_irq = 0;
3630 bttv_buffer_activate_video(btv, &new);
3631 bttv_buffer_activate_vbi(btv, NULL);
3632 bttv_set_dma(btv, 0);
3633
3634
3635 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3636 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3637
3638
3639 while (!list_empty(&btv->capture)) {
3640 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3641 list_del(&item->vb.queue);
3642 item->vb.state = VIDEOBUF_ERROR;
3643 wake_up(&item->vb.done);
3644 }
3645 while (!list_empty(&btv->vcapture)) {
3646 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3647 list_del(&item->vb.queue);
3648 item->vb.state = VIDEOBUF_ERROR;
3649 wake_up(&item->vb.done);
3650 }
3651
3652 btv->errors++;
3653 spin_unlock_irqrestore(&btv->s_lock,flags);
3654}
3655
3656static void
3657bttv_irq_wakeup_top(struct bttv *btv)
3658{
3659 struct bttv_buffer *wakeup = btv->curr.top;
3660
3661 if (NULL == wakeup)
3662 return;
3663
3664 spin_lock(&btv->s_lock);
3665 btv->curr.top_irq = 0;
3666 btv->curr.top = NULL;
3667 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3668
3669 v4l2_get_timestamp(&wakeup->vb.ts);
3670 wakeup->vb.field_count = btv->field_count;
3671 wakeup->vb.state = VIDEOBUF_DONE;
3672 wake_up(&wakeup->vb.done);
3673 spin_unlock(&btv->s_lock);
3674}
3675
3676static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3677{
3678 if (rc < risc->dma)
3679 return 0;
3680 if (rc > risc->dma + risc->size)
3681 return 0;
3682 return 1;
3683}
3684
3685static void
3686bttv_irq_switch_video(struct bttv *btv)
3687{
3688 struct bttv_buffer_set new;
3689 struct bttv_buffer_set old;
3690 dma_addr_t rc;
3691
3692 spin_lock(&btv->s_lock);
3693
3694
3695 bttv_irq_next_video(btv, &new);
3696 rc = btread(BT848_RISC_COUNT);
3697 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3698 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3699 btv->framedrop++;
3700 if (debug_latency)
3701 bttv_irq_debug_low_latency(btv, rc);
3702 spin_unlock(&btv->s_lock);
3703 return;
3704 }
3705
3706
3707 old = btv->curr;
3708 btv->curr = new;
3709 btv->loop_irq &= ~1;
3710 bttv_buffer_activate_video(btv, &new);
3711 bttv_set_dma(btv, 0);
3712
3713
3714 if (UNSET != btv->new_input) {
3715 video_mux(btv,btv->new_input);
3716 btv->new_input = UNSET;
3717 }
3718
3719
3720 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
3721 spin_unlock(&btv->s_lock);
3722}
3723
3724static void
3725bttv_irq_switch_vbi(struct bttv *btv)
3726{
3727 struct bttv_buffer *new = NULL;
3728 struct bttv_buffer *old;
3729 u32 rc;
3730
3731 spin_lock(&btv->s_lock);
3732
3733 if (!list_empty(&btv->vcapture))
3734 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3735 old = btv->cvbi;
3736
3737 rc = btread(BT848_RISC_COUNT);
3738 if (NULL != old && (is_active(&old->top, rc) ||
3739 is_active(&old->bottom, rc))) {
3740 btv->framedrop++;
3741 if (debug_latency)
3742 bttv_irq_debug_low_latency(btv, rc);
3743 spin_unlock(&btv->s_lock);
3744 return;
3745 }
3746
3747
3748 btv->cvbi = new;
3749 btv->loop_irq &= ~4;
3750 bttv_buffer_activate_vbi(btv, new);
3751 bttv_set_dma(btv, 0);
3752
3753 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
3754 spin_unlock(&btv->s_lock);
3755}
3756
3757static irqreturn_t bttv_irq(int irq, void *dev_id)
3758{
3759 u32 stat,astat;
3760 u32 dstat;
3761 int count;
3762 struct bttv *btv;
3763 int handled = 0;
3764
3765 btv=(struct bttv *)dev_id;
3766
3767 count=0;
3768 while (1) {
3769
3770 stat=btread(BT848_INT_STAT);
3771 astat=stat&btread(BT848_INT_MASK);
3772 if (!astat)
3773 break;
3774 handled = 1;
3775 btwrite(stat,BT848_INT_STAT);
3776
3777
3778 dstat=btread(BT848_DSTATUS);
3779
3780 if (irq_debug) {
3781 pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ",
3782 btv->c.nr, count, btv->field_count,
3783 stat>>28, btread(BT848_RISC_COUNT));
3784 bttv_print_irqbits(stat,astat);
3785 if (stat & BT848_INT_HLOCK)
3786 pr_cont(" HLOC => %s",
3787 dstat & BT848_DSTATUS_HLOC
3788 ? "yes" : "no");
3789 if (stat & BT848_INT_VPRES)
3790 pr_cont(" PRES => %s",
3791 dstat & BT848_DSTATUS_PRES
3792 ? "yes" : "no");
3793 if (stat & BT848_INT_FMTCHG)
3794 pr_cont(" NUML => %s",
3795 dstat & BT848_DSTATUS_NUML
3796 ? "625" : "525");
3797 pr_cont("\n");
3798 }
3799
3800 if (astat&BT848_INT_VSYNC)
3801 btv->field_count++;
3802
3803 if ((astat & BT848_INT_GPINT) && btv->remote) {
3804 bttv_input_irq(btv);
3805 }
3806
3807 if (astat & BT848_INT_I2CDONE) {
3808 btv->i2c_done = stat;
3809 wake_up(&btv->i2c_queue);
3810 }
3811
3812 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
3813 bttv_irq_switch_vbi(btv);
3814
3815 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
3816 bttv_irq_wakeup_top(btv);
3817
3818 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
3819 bttv_irq_switch_video(btv);
3820
3821 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
3822
3823 audio_mux_gpio(btv, btv->audio_input, btv->mute);
3824
3825 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3826 pr_info("%d: %s%s @ %08x,",
3827 btv->c.nr,
3828 (astat & BT848_INT_SCERR) ? "SCERR" : "",
3829 (astat & BT848_INT_OCERR) ? "OCERR" : "",
3830 btread(BT848_RISC_COUNT));
3831 bttv_print_irqbits(stat,astat);
3832 pr_cont("\n");
3833 if (bttv_debug)
3834 bttv_print_riscaddr(btv);
3835 }
3836 if (fdsr && astat & BT848_INT_FDSR) {
3837 pr_info("%d: FDSR @ %08x\n",
3838 btv->c.nr, btread(BT848_RISC_COUNT));
3839 if (bttv_debug)
3840 bttv_print_riscaddr(btv);
3841 }
3842
3843 count++;
3844 if (count > 4) {
3845
3846 if (count > 8 || !(astat & BT848_INT_GPINT)) {
3847 btwrite(0, BT848_INT_MASK);
3848
3849 pr_err("%d: IRQ lockup, cleared int mask [",
3850 btv->c.nr);
3851 } else {
3852 pr_err("%d: IRQ lockup, clearing GPINT from int mask [",
3853 btv->c.nr);
3854
3855 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3856 BT848_INT_MASK);
3857 };
3858
3859 bttv_print_irqbits(stat,astat);
3860
3861 pr_cont("]\n");
3862 }
3863 }
3864 btv->irq_total++;
3865 if (handled)
3866 btv->irq_me++;
3867 return IRQ_RETVAL(handled);
3868}
3869
3870
3871
3872
3873
3874static struct video_device *vdev_init(struct bttv *btv,
3875 const struct video_device *template,
3876 const char *type_name)
3877{
3878 struct video_device *vfd;
3879
3880 vfd = video_device_alloc();
3881 if (NULL == vfd)
3882 return NULL;
3883 *vfd = *template;
3884 vfd->v4l2_dev = &btv->c.v4l2_dev;
3885 vfd->release = video_device_release;
3886 vfd->debug = bttv_debug;
3887 set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
3888 video_set_drvdata(vfd, btv);
3889 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3890 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3891 type_name, bttv_tvcards[btv->c.type].name);
3892 if (btv->tuner_type == TUNER_ABSENT) {
3893 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY);
3894 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY);
3895 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
3896 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
3897 }
3898 return vfd;
3899}
3900
3901static void bttv_unregister_video(struct bttv *btv)
3902{
3903 if (btv->video_dev) {
3904 if (video_is_registered(btv->video_dev))
3905 video_unregister_device(btv->video_dev);
3906 else
3907 video_device_release(btv->video_dev);
3908 btv->video_dev = NULL;
3909 }
3910 if (btv->vbi_dev) {
3911 if (video_is_registered(btv->vbi_dev))
3912 video_unregister_device(btv->vbi_dev);
3913 else
3914 video_device_release(btv->vbi_dev);
3915 btv->vbi_dev = NULL;
3916 }
3917 if (btv->radio_dev) {
3918 if (video_is_registered(btv->radio_dev))
3919 video_unregister_device(btv->radio_dev);
3920 else
3921 video_device_release(btv->radio_dev);
3922 btv->radio_dev = NULL;
3923 }
3924}
3925
3926
3927static int bttv_register_video(struct bttv *btv)
3928{
3929 if (no_overlay > 0)
3930 pr_notice("Overlay support disabled\n");
3931
3932
3933 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
3934
3935 if (NULL == btv->video_dev)
3936 goto err;
3937 if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
3938 video_nr[btv->c.nr]) < 0)
3939 goto err;
3940 pr_info("%d: registered device %s\n",
3941 btv->c.nr, video_device_node_name(btv->video_dev));
3942 if (device_create_file(&btv->video_dev->dev,
3943 &dev_attr_card)<0) {
3944 pr_err("%d: device_create_file 'card' failed\n", btv->c.nr);
3945 goto err;
3946 }
3947
3948
3949 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
3950
3951 if (NULL == btv->vbi_dev)
3952 goto err;
3953 if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
3954 vbi_nr[btv->c.nr]) < 0)
3955 goto err;
3956 pr_info("%d: registered device %s\n",
3957 btv->c.nr, video_device_node_name(btv->vbi_dev));
3958
3959 if (!btv->has_radio)
3960 return 0;
3961
3962 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
3963 if (NULL == btv->radio_dev)
3964 goto err;
3965 btv->radio_dev->ctrl_handler = &btv->radio_ctrl_handler;
3966 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
3967 radio_nr[btv->c.nr]) < 0)
3968 goto err;
3969 pr_info("%d: registered device %s\n",
3970 btv->c.nr, video_device_node_name(btv->radio_dev));
3971
3972
3973 return 0;
3974
3975 err:
3976 bttv_unregister_video(btv);
3977 return -1;
3978}
3979
3980
3981
3982
3983static void pci_set_command(struct pci_dev *dev)
3984{
3985#if defined(__powerpc__)
3986 unsigned int cmd;
3987
3988 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3989 cmd = (cmd | PCI_COMMAND_MEMORY );
3990 pci_write_config_dword(dev, PCI_COMMAND, cmd);
3991#endif
3992}
3993
3994static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
3995{
3996 struct v4l2_frequency init_freq = {
3997 .tuner = 0,
3998 .type = V4L2_TUNER_ANALOG_TV,
3999 .frequency = 980,
4000 };
4001 int result;
4002 unsigned char lat;
4003 struct bttv *btv;
4004 struct v4l2_ctrl_handler *hdl;
4005
4006 if (bttv_num == BTTV_MAX)
4007 return -ENOMEM;
4008 pr_info("Bt8xx card found (%d)\n", bttv_num);
4009 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4010 if (btv == NULL) {
4011 pr_err("out of memory\n");
4012 return -ENOMEM;
4013 }
4014 btv->c.nr = bttv_num;
4015 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4016 "bttv%d", btv->c.nr);
4017
4018
4019 mutex_init(&btv->lock);
4020 spin_lock_init(&btv->s_lock);
4021 spin_lock_init(&btv->gpio_lock);
4022 init_waitqueue_head(&btv->i2c_queue);
4023 INIT_LIST_HEAD(&btv->c.subs);
4024 INIT_LIST_HEAD(&btv->capture);
4025 INIT_LIST_HEAD(&btv->vcapture);
4026
4027 init_timer(&btv->timeout);
4028 btv->timeout.function = bttv_irq_timeout;
4029 btv->timeout.data = (unsigned long)btv;
4030
4031 btv->i2c_rc = -1;
4032 btv->tuner_type = UNSET;
4033 btv->new_input = UNSET;
4034 btv->has_radio=radio[btv->c.nr];
4035
4036
4037 btv->c.pci = dev;
4038 btv->id = dev->device;
4039 if (pci_enable_device(dev)) {
4040 pr_warn("%d: Can't enable device\n", btv->c.nr);
4041 return -EIO;
4042 }
4043 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4044 pr_warn("%d: No suitable DMA available\n", btv->c.nr);
4045 return -EIO;
4046 }
4047 if (!request_mem_region(pci_resource_start(dev,0),
4048 pci_resource_len(dev,0),
4049 btv->c.v4l2_dev.name)) {
4050 pr_warn("%d: can't request iomem (0x%llx)\n",
4051 btv->c.nr,
4052 (unsigned long long)pci_resource_start(dev, 0));
4053 return -EBUSY;
4054 }
4055 pci_set_master(dev);
4056 pci_set_command(dev);
4057
4058 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4059 if (result < 0) {
4060 pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr);
4061 goto fail0;
4062 }
4063 hdl = &btv->ctrl_handler;
4064 v4l2_ctrl_handler_init(hdl, 20);
4065 btv->c.v4l2_dev.ctrl_handler = hdl;
4066 v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6);
4067
4068 btv->revision = dev->revision;
4069 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4070 pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n",
4071 bttv_num, btv->id, btv->revision, pci_name(dev),
4072 btv->c.pci->irq, lat,
4073 (unsigned long long)pci_resource_start(dev, 0));
4074 schedule();
4075
4076 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4077 if (NULL == btv->bt848_mmio) {
4078 pr_err("%d: ioremap() failed\n", btv->c.nr);
4079 result = -EIO;
4080 goto fail1;
4081 }
4082
4083
4084 bttv_idcard(btv);
4085
4086
4087 btwrite(0, BT848_INT_MASK);
4088 result = request_irq(btv->c.pci->irq, bttv_irq,
4089 IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4090 if (result < 0) {
4091 pr_err("%d: can't get IRQ %d\n",
4092 bttv_num, btv->c.pci->irq);
4093 goto fail1;
4094 }
4095
4096 if (0 != bttv_handle_chipset(btv)) {
4097 result = -EIO;
4098 goto fail2;
4099 }
4100
4101
4102 btv->opt_combfilter = combfilter;
4103 bttv_ctrl_combfilter.def = combfilter;
4104 bttv_ctrl_lumafilter.def = lumafilter;
4105 btv->opt_automute = automute;
4106 bttv_ctrl_automute.def = automute;
4107 bttv_ctrl_agc_crush.def = agc_crush;
4108 btv->opt_vcr_hack = vcr_hack;
4109 bttv_ctrl_vcr_hack.def = vcr_hack;
4110 bttv_ctrl_whitecrush_upper.def = whitecrush_upper;
4111 bttv_ctrl_whitecrush_lower.def = whitecrush_lower;
4112 btv->opt_uv_ratio = uv_ratio;
4113 bttv_ctrl_uv_ratio.def = uv_ratio;
4114 bttv_ctrl_full_luma.def = full_luma_range;
4115 bttv_ctrl_coring.def = coring;
4116
4117
4118 btv->init.btv = btv;
4119 btv->init.ov.w.width = 320;
4120 btv->init.ov.w.height = 240;
4121 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4122 btv->init.width = 320;
4123 btv->init.height = 240;
4124 btv->init.ov.w.width = 320;
4125 btv->init.ov.w.height = 240;
4126 btv->init.ov.field = V4L2_FIELD_INTERLACED;
4127 btv->input = 0;
4128
4129 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4130 V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768);
4131 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4132 V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00);
4133 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4134 V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768);
4135 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4136 V4L2_CID_COLOR_KILLER, 0, 1, 1, 0);
4137 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4138 V4L2_CID_HUE, 0, 0xff00, 0x100, 32768);
4139 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4140 V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc);
4141 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4142 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
4143 if (btv->volume_gpio)
4144 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4145 V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00);
4146 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL);
4147 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL);
4148 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL);
4149 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL);
4150 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL);
4151 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL);
4152 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL);
4153 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL);
4154 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL);
4155 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL);
4156
4157
4158 if (bttv_gpio)
4159 bttv_gpio_tracking(btv,"pre-init");
4160
4161 bttv_risc_init_main(btv);
4162 init_bt848(btv);
4163
4164
4165 btwrite(0x00, BT848_GPIO_REG_INP);
4166 btwrite(0x00, BT848_GPIO_OUT_EN);
4167 if (bttv_verbose)
4168 bttv_gpio_tracking(btv,"init");
4169
4170
4171 bttv_init_card1(btv);
4172
4173
4174 init_bttv_i2c(btv);
4175
4176
4177 bttv_init_card2(btv);
4178 bttv_init_tuner(btv);
4179 if (btv->tuner_type != TUNER_ABSENT) {
4180 bttv_set_frequency(btv, &init_freq);
4181 btv->radio_freq = 90500 * 16;
4182 }
4183 btv->std = V4L2_STD_PAL;
4184 init_irqreg(btv);
4185 v4l2_ctrl_handler_setup(hdl);
4186 if (hdl->error) {
4187 result = hdl->error;
4188 goto fail2;
4189 }
4190
4191 audio_mute(btv, 1);
4192
4193
4194 if (!bttv_tvcards[btv->c.type].no_video) {
4195 v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl,
4196 v4l2_ctrl_radio_filter);
4197 if (btv->radio_ctrl_handler.error) {
4198 result = btv->radio_ctrl_handler.error;
4199 goto fail2;
4200 }
4201 set_input(btv, 0, btv->tvnorm);
4202 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4203 btv->crop[1] = btv->crop[0];
4204 disclaim_vbi_lines(btv);
4205 disclaim_video_lines(btv);
4206 bttv_register_video(btv);
4207 }
4208
4209
4210 if (bttv_tvcards[btv->c.type].has_dvb) {
4211 bttv_sub_add_device(&btv->c, "dvb");
4212 request_modules(btv);
4213 }
4214
4215 if (!disable_ir) {
4216 init_bttv_i2c_ir(btv);
4217 bttv_input_init(btv);
4218 }
4219
4220
4221 bttv_num++;
4222 return 0;
4223
4224fail2:
4225 free_irq(btv->c.pci->irq,btv);
4226
4227fail1:
4228 v4l2_ctrl_handler_free(&btv->ctrl_handler);
4229 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
4230 v4l2_device_unregister(&btv->c.v4l2_dev);
4231
4232fail0:
4233 if (btv->bt848_mmio)
4234 iounmap(btv->bt848_mmio);
4235 release_mem_region(pci_resource_start(btv->c.pci,0),
4236 pci_resource_len(btv->c.pci,0));
4237 return result;
4238}
4239
4240static void bttv_remove(struct pci_dev *pci_dev)
4241{
4242 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4243 struct bttv *btv = to_bttv(v4l2_dev);
4244
4245 if (bttv_verbose)
4246 pr_info("%d: unloading\n", btv->c.nr);
4247
4248 if (bttv_tvcards[btv->c.type].has_dvb)
4249 flush_request_modules(btv);
4250
4251
4252 btand(~15, BT848_GPIO_DMA_CTL);
4253 btwrite(0, BT848_INT_MASK);
4254 btwrite(~0x0, BT848_INT_STAT);
4255 btwrite(0x0, BT848_GPIO_OUT_EN);
4256 if (bttv_gpio)
4257 bttv_gpio_tracking(btv,"cleanup");
4258
4259
4260 btv->shutdown=1;
4261 bttv_input_fini(btv);
4262 bttv_sub_del_devices(&btv->c);
4263
4264
4265 fini_bttv_i2c(btv);
4266
4267
4268 bttv_unregister_video(btv);
4269
4270
4271 v4l2_ctrl_handler_free(&btv->ctrl_handler);
4272 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
4273 btcx_riscmem_free(btv->c.pci,&btv->main);
4274
4275
4276 free_irq(btv->c.pci->irq,btv);
4277 iounmap(btv->bt848_mmio);
4278 release_mem_region(pci_resource_start(btv->c.pci,0),
4279 pci_resource_len(btv->c.pci,0));
4280
4281 v4l2_device_unregister(&btv->c.v4l2_dev);
4282 bttvs[btv->c.nr] = NULL;
4283 kfree(btv);
4284
4285 return;
4286}
4287
4288#ifdef CONFIG_PM
4289static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4290{
4291 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4292 struct bttv *btv = to_bttv(v4l2_dev);
4293 struct bttv_buffer_set idle;
4294 unsigned long flags;
4295
4296 dprintk("%d: suspend %d\n", btv->c.nr, state.event);
4297
4298
4299 spin_lock_irqsave(&btv->s_lock,flags);
4300 memset(&idle, 0, sizeof(idle));
4301 btv->state.video = btv->curr;
4302 btv->state.vbi = btv->cvbi;
4303 btv->state.loop_irq = btv->loop_irq;
4304 btv->curr = idle;
4305 btv->loop_irq = 0;
4306 bttv_buffer_activate_video(btv, &idle);
4307 bttv_buffer_activate_vbi(btv, NULL);
4308 bttv_set_dma(btv, 0);
4309 btwrite(0, BT848_INT_MASK);
4310 spin_unlock_irqrestore(&btv->s_lock,flags);
4311
4312
4313 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4314 btv->state.gpio_data = gpio_read();
4315
4316
4317 pci_save_state(pci_dev);
4318 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4319 pci_disable_device(pci_dev);
4320 btv->state.disabled = 1;
4321 }
4322 return 0;
4323}
4324
4325static int bttv_resume(struct pci_dev *pci_dev)
4326{
4327 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4328 struct bttv *btv = to_bttv(v4l2_dev);
4329 unsigned long flags;
4330 int err;
4331
4332 dprintk("%d: resume\n", btv->c.nr);
4333
4334
4335 if (btv->state.disabled) {
4336 err=pci_enable_device(pci_dev);
4337 if (err) {
4338 pr_warn("%d: Can't enable device\n", btv->c.nr);
4339 return err;
4340 }
4341 btv->state.disabled = 0;
4342 }
4343 err=pci_set_power_state(pci_dev, PCI_D0);
4344 if (err) {
4345 pci_disable_device(pci_dev);
4346 pr_warn("%d: Can't enable device\n", btv->c.nr);
4347 btv->state.disabled = 1;
4348 return err;
4349 }
4350
4351 pci_restore_state(pci_dev);
4352
4353
4354 bttv_reinit_bt848(btv);
4355 gpio_inout(0xffffff, btv->state.gpio_enable);
4356 gpio_write(btv->state.gpio_data);
4357
4358
4359 spin_lock_irqsave(&btv->s_lock,flags);
4360 btv->curr = btv->state.video;
4361 btv->cvbi = btv->state.vbi;
4362 btv->loop_irq = btv->state.loop_irq;
4363 bttv_buffer_activate_video(btv, &btv->curr);
4364 bttv_buffer_activate_vbi(btv, btv->cvbi);
4365 bttv_set_dma(btv, 0);
4366 spin_unlock_irqrestore(&btv->s_lock,flags);
4367 return 0;
4368}
4369#endif
4370
4371static struct pci_device_id bttv_pci_tbl[] = {
4372 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4373 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4374 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4375 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4376 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
4377 {0,}
4378};
4379
4380MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4381
4382static struct pci_driver bttv_pci_driver = {
4383 .name = "bttv",
4384 .id_table = bttv_pci_tbl,
4385 .probe = bttv_probe,
4386 .remove = bttv_remove,
4387#ifdef CONFIG_PM
4388 .suspend = bttv_suspend,
4389 .resume = bttv_resume,
4390#endif
4391};
4392
4393static int __init bttv_init_module(void)
4394{
4395 int ret;
4396
4397 bttv_num = 0;
4398
4399 pr_info("driver version %s loaded\n", BTTV_VERSION);
4400 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4401 gbuffers = 2;
4402 if (gbufsize > BTTV_MAX_FBUF)
4403 gbufsize = BTTV_MAX_FBUF;
4404 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4405 if (bttv_verbose)
4406 pr_info("using %d buffers with %dk (%d pages) each for capture\n",
4407 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4408
4409 bttv_check_chipset();
4410
4411 ret = bus_register(&bttv_sub_bus_type);
4412 if (ret < 0) {
4413 pr_warn("bus_register error: %d\n", ret);
4414 return ret;
4415 }
4416 ret = pci_register_driver(&bttv_pci_driver);
4417 if (ret < 0)
4418 bus_unregister(&bttv_sub_bus_type);
4419
4420 return ret;
4421}
4422
4423static void __exit bttv_cleanup_module(void)
4424{
4425 pci_unregister_driver(&bttv_pci_driver);
4426 bus_unregister(&bttv_sub_bus_type);
4427}
4428
4429module_init(bttv_init_module);
4430module_exit(bttv_cleanup_module);
4431
4432
4433
4434
4435
4436
4437