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