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