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