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