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