Driver Core: devtmpfs - kernel-maintained tmpfs-based /dev
[linux/fpc-iii.git] / drivers / media / video / bt8xx / bttv-driver.c
blob8cc6dd28d6a7a1ca4109064d6d98994d280003a2
1 /*
3 bttv - Bt848 frame grabber driver
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>
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>
12 V4L1 removal from:
13 (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
15 Fixes to be fully V4L2 compliant by
16 (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
18 Cropping and overscan support
19 Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
20 Sponsored by OPQ Systems AB
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
37 #include <linux/init.h>
38 #include <linux/module.h>
39 #include <linux/delay.h>
40 #include <linux/errno.h>
41 #include <linux/fs.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/smp_lock.h>
45 #include <linux/interrupt.h>
46 #include <linux/kdev_t.h>
47 #include "bttvp.h"
48 #include <media/v4l2-common.h>
49 #include <media/v4l2-ioctl.h>
50 #include <media/tvaudio.h>
51 #include <media/msp3400.h>
53 #include <linux/dma-mapping.h>
55 #include <asm/io.h>
56 #include <asm/byteorder.h>
58 #include <media/rds.h>
61 unsigned int bttv_num; /* number of Bt848s in use */
62 struct bttv *bttvs[BTTV_MAX];
64 unsigned int bttv_debug;
65 unsigned int bttv_verbose = 1;
66 unsigned int bttv_gpio;
68 /* config variables */
69 #ifdef __BIG_ENDIAN
70 static unsigned int bigendian=1;
71 #else
72 static unsigned int bigendian;
73 #endif
74 static unsigned int radio[BTTV_MAX];
75 static unsigned int irq_debug;
76 static unsigned int gbuffers = 8;
77 static unsigned int gbufsize = 0x208000;
78 static unsigned int reset_crop = 1;
80 static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
81 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
82 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
83 static int debug_latency;
85 static unsigned int fdsr;
87 /* options */
88 static unsigned int combfilter;
89 static unsigned int lumafilter;
90 static unsigned int automute = 1;
91 static unsigned int chroma_agc;
92 static unsigned int adc_crush = 1;
93 static unsigned int whitecrush_upper = 0xCF;
94 static unsigned int whitecrush_lower = 0x7F;
95 static unsigned int vcr_hack;
96 static unsigned int irq_iswitch;
97 static unsigned int uv_ratio = 50;
98 static unsigned int full_luma_range;
99 static unsigned int coring;
101 /* API features (turn on/off stuff for testing) */
102 static unsigned int v4l2 = 1;
104 /* insmod args */
105 module_param(bttv_verbose, int, 0644);
106 module_param(bttv_gpio, int, 0644);
107 module_param(bttv_debug, int, 0644);
108 module_param(irq_debug, int, 0644);
109 module_param(debug_latency, int, 0644);
111 module_param(fdsr, int, 0444);
112 module_param(gbuffers, int, 0444);
113 module_param(gbufsize, int, 0444);
114 module_param(reset_crop, int, 0444);
116 module_param(v4l2, int, 0644);
117 module_param(bigendian, int, 0644);
118 module_param(irq_iswitch, int, 0644);
119 module_param(combfilter, int, 0444);
120 module_param(lumafilter, int, 0444);
121 module_param(automute, int, 0444);
122 module_param(chroma_agc, int, 0444);
123 module_param(adc_crush, int, 0444);
124 module_param(whitecrush_upper, int, 0444);
125 module_param(whitecrush_lower, int, 0444);
126 module_param(vcr_hack, int, 0444);
127 module_param(uv_ratio, int, 0444);
128 module_param(full_luma_range, int, 0444);
129 module_param(coring, int, 0444);
131 module_param_array(radio, int, NULL, 0444);
132 module_param_array(video_nr, int, NULL, 0444);
133 module_param_array(radio_nr, int, NULL, 0444);
134 module_param_array(vbi_nr, int, NULL, 0444);
136 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
137 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
138 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
139 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
140 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
141 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
142 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
143 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
144 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
145 "is 1 (yes) for compatibility with older applications");
146 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
147 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
148 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
149 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
150 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
151 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
152 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
153 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
154 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
155 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
156 MODULE_PARM_DESC(video_nr, "video device numbers");
157 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
158 MODULE_PARM_DESC(radio_nr, "radio device numbers");
160 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
161 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
162 MODULE_LICENSE("GPL");
164 /* ----------------------------------------------------------------------- */
165 /* sysfs */
167 static ssize_t show_card(struct device *cd,
168 struct device_attribute *attr, char *buf)
170 struct video_device *vfd = container_of(cd, struct video_device, dev);
171 struct bttv *btv = video_get_drvdata(vfd);
172 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
174 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
176 /* ----------------------------------------------------------------------- */
177 /* dvb auto-load setup */
178 #if defined(CONFIG_MODULES) && defined(MODULE)
179 static void request_module_async(struct work_struct *work)
181 request_module("dvb-bt8xx");
184 static void request_modules(struct bttv *dev)
186 INIT_WORK(&dev->request_module_wk, request_module_async);
187 schedule_work(&dev->request_module_wk);
189 #else
190 #define request_modules(dev)
191 #endif /* CONFIG_MODULES */
194 /* ----------------------------------------------------------------------- */
195 /* static data */
197 /* special timing tables from conexant... */
198 static u8 SRAM_Table[][60] =
200 /* PAL digital input over GPIO[7:0] */
202 45, // 45 bytes following
203 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
204 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
205 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
206 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
207 0x37,0x00,0xAF,0x21,0x00
209 /* NTSC digital input over GPIO[7:0] */
211 51, // 51 bytes following
212 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
213 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
214 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
215 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
216 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
217 0x00,
219 // TGB_NTSC392 // quartzsight
220 // This table has been modified to be used for Fusion Rev D
222 0x2A, // size of table = 42
223 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
224 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
225 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
226 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
227 0x20, 0x00
231 /* minhdelayx1 first video pixel we can capture on a line and
232 hdelayx1 start of active video, both relative to rising edge of
233 /HRESET pulse (0H) in 1 / fCLKx1.
234 swidth width of active video and
235 totalwidth total line width, both in 1 / fCLKx1.
236 sqwidth total line width in square pixels.
237 vdelay start of active video in 2 * field lines relative to
238 trailing edge of /VRESET pulse (VDELAY register).
239 sheight height of active video in 2 * field lines.
240 videostart0 ITU-R frame line number of the line corresponding
241 to vdelay in the first field. */
242 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
243 vdelay, sheight, videostart0) \
244 .cropcap.bounds.left = minhdelayx1, \
245 /* * 2 because vertically we count field lines times two, */ \
246 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
247 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
248 /* 4 is a safety margin at the end of the line. */ \
249 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
250 .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY, \
251 .cropcap.defrect.left = hdelayx1, \
252 .cropcap.defrect.top = (videostart0) * 2, \
253 .cropcap.defrect.width = swidth, \
254 .cropcap.defrect.height = sheight, \
255 .cropcap.pixelaspect.numerator = totalwidth, \
256 .cropcap.pixelaspect.denominator = sqwidth,
258 const struct bttv_tvnorm bttv_tvnorms[] = {
259 /* PAL-BDGHI */
260 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
261 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
263 .v4l2_id = V4L2_STD_PAL,
264 .name = "PAL",
265 .Fsc = 35468950,
266 .swidth = 924,
267 .sheight = 576,
268 .totalwidth = 1135,
269 .adelay = 0x7f,
270 .bdelay = 0x72,
271 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
272 .scaledtwidth = 1135,
273 .hdelayx1 = 186,
274 .hactivex1 = 924,
275 .vdelay = 0x20,
276 .vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */
277 .sram = 0,
278 /* ITU-R frame line number of the first VBI line
279 we can capture, of the first and second field.
280 The last line is determined by cropcap.bounds. */
281 .vbistart = { 7, 320 },
282 CROPCAP(/* minhdelayx1 */ 68,
283 /* hdelayx1 */ 186,
284 /* Should be (768 * 1135 + 944 / 2) / 944.
285 cropcap.defrect is used for image width
286 checks, so we keep the old value 924. */
287 /* swidth */ 924,
288 /* totalwidth */ 1135,
289 /* sqwidth */ 944,
290 /* vdelay */ 0x20,
291 /* sheight */ 576,
292 /* videostart0 */ 23)
293 /* bt878 (and bt848?) can capture another
294 line below active video. */
295 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
297 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
298 .name = "NTSC",
299 .Fsc = 28636363,
300 .swidth = 768,
301 .sheight = 480,
302 .totalwidth = 910,
303 .adelay = 0x68,
304 .bdelay = 0x5d,
305 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
306 .scaledtwidth = 910,
307 .hdelayx1 = 128,
308 .hactivex1 = 910,
309 .vdelay = 0x1a,
310 .vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */
311 .sram = 1,
312 .vbistart = { 10, 273 },
313 CROPCAP(/* minhdelayx1 */ 68,
314 /* hdelayx1 */ 128,
315 /* Should be (640 * 910 + 780 / 2) / 780? */
316 /* swidth */ 768,
317 /* totalwidth */ 910,
318 /* sqwidth */ 780,
319 /* vdelay */ 0x1a,
320 /* sheight */ 480,
321 /* videostart0 */ 23)
323 .v4l2_id = V4L2_STD_SECAM,
324 .name = "SECAM",
325 .Fsc = 35468950,
326 .swidth = 924,
327 .sheight = 576,
328 .totalwidth = 1135,
329 .adelay = 0x7f,
330 .bdelay = 0xb0,
331 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
332 .scaledtwidth = 1135,
333 .hdelayx1 = 186,
334 .hactivex1 = 922,
335 .vdelay = 0x20,
336 .vbipack = 255,
337 .sram = 0, /* like PAL, correct? */
338 .vbistart = { 7, 320 },
339 CROPCAP(/* minhdelayx1 */ 68,
340 /* hdelayx1 */ 186,
341 /* swidth */ 924,
342 /* totalwidth */ 1135,
343 /* sqwidth */ 944,
344 /* vdelay */ 0x20,
345 /* sheight */ 576,
346 /* videostart0 */ 23)
348 .v4l2_id = V4L2_STD_PAL_Nc,
349 .name = "PAL-Nc",
350 .Fsc = 28636363,
351 .swidth = 640,
352 .sheight = 576,
353 .totalwidth = 910,
354 .adelay = 0x68,
355 .bdelay = 0x5d,
356 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
357 .scaledtwidth = 780,
358 .hdelayx1 = 130,
359 .hactivex1 = 734,
360 .vdelay = 0x1a,
361 .vbipack = 144,
362 .sram = -1,
363 .vbistart = { 7, 320 },
364 CROPCAP(/* minhdelayx1 */ 68,
365 /* hdelayx1 */ 130,
366 /* swidth */ (640 * 910 + 780 / 2) / 780,
367 /* totalwidth */ 910,
368 /* sqwidth */ 780,
369 /* vdelay */ 0x1a,
370 /* sheight */ 576,
371 /* videostart0 */ 23)
373 .v4l2_id = V4L2_STD_PAL_M,
374 .name = "PAL-M",
375 .Fsc = 28636363,
376 .swidth = 640,
377 .sheight = 480,
378 .totalwidth = 910,
379 .adelay = 0x68,
380 .bdelay = 0x5d,
381 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
382 .scaledtwidth = 780,
383 .hdelayx1 = 135,
384 .hactivex1 = 754,
385 .vdelay = 0x1a,
386 .vbipack = 144,
387 .sram = -1,
388 .vbistart = { 10, 273 },
389 CROPCAP(/* minhdelayx1 */ 68,
390 /* hdelayx1 */ 135,
391 /* swidth */ (640 * 910 + 780 / 2) / 780,
392 /* totalwidth */ 910,
393 /* sqwidth */ 780,
394 /* vdelay */ 0x1a,
395 /* sheight */ 480,
396 /* videostart0 */ 23)
398 .v4l2_id = V4L2_STD_PAL_N,
399 .name = "PAL-N",
400 .Fsc = 35468950,
401 .swidth = 768,
402 .sheight = 576,
403 .totalwidth = 1135,
404 .adelay = 0x7f,
405 .bdelay = 0x72,
406 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
407 .scaledtwidth = 944,
408 .hdelayx1 = 186,
409 .hactivex1 = 922,
410 .vdelay = 0x20,
411 .vbipack = 144,
412 .sram = -1,
413 .vbistart = { 7, 320 },
414 CROPCAP(/* minhdelayx1 */ 68,
415 /* hdelayx1 */ 186,
416 /* swidth */ (768 * 1135 + 944 / 2) / 944,
417 /* totalwidth */ 1135,
418 /* sqwidth */ 944,
419 /* vdelay */ 0x20,
420 /* sheight */ 576,
421 /* videostart0 */ 23)
423 .v4l2_id = V4L2_STD_NTSC_M_JP,
424 .name = "NTSC-JP",
425 .Fsc = 28636363,
426 .swidth = 640,
427 .sheight = 480,
428 .totalwidth = 910,
429 .adelay = 0x68,
430 .bdelay = 0x5d,
431 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
432 .scaledtwidth = 780,
433 .hdelayx1 = 135,
434 .hactivex1 = 754,
435 .vdelay = 0x16,
436 .vbipack = 144,
437 .sram = -1,
438 .vbistart = { 10, 273 },
439 CROPCAP(/* minhdelayx1 */ 68,
440 /* hdelayx1 */ 135,
441 /* swidth */ (640 * 910 + 780 / 2) / 780,
442 /* totalwidth */ 910,
443 /* sqwidth */ 780,
444 /* vdelay */ 0x16,
445 /* sheight */ 480,
446 /* videostart0 */ 23)
448 /* that one hopefully works with the strange timing
449 * which video recorders produce when playing a NTSC
450 * tape on a PAL TV ... */
451 .v4l2_id = V4L2_STD_PAL_60,
452 .name = "PAL-60",
453 .Fsc = 35468950,
454 .swidth = 924,
455 .sheight = 480,
456 .totalwidth = 1135,
457 .adelay = 0x7f,
458 .bdelay = 0x72,
459 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
460 .scaledtwidth = 1135,
461 .hdelayx1 = 186,
462 .hactivex1 = 924,
463 .vdelay = 0x1a,
464 .vbipack = 255,
465 .vtotal = 524,
466 .sram = -1,
467 .vbistart = { 10, 273 },
468 CROPCAP(/* minhdelayx1 */ 68,
469 /* hdelayx1 */ 186,
470 /* swidth */ 924,
471 /* totalwidth */ 1135,
472 /* sqwidth */ 944,
473 /* vdelay */ 0x1a,
474 /* sheight */ 480,
475 /* videostart0 */ 23)
478 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
480 /* ----------------------------------------------------------------------- */
481 /* bttv format list
482 packed pixel formats must come first */
483 static const struct bttv_format formats[] = {
485 .name = "8 bpp, gray",
486 .fourcc = V4L2_PIX_FMT_GREY,
487 .btformat = BT848_COLOR_FMT_Y8,
488 .depth = 8,
489 .flags = FORMAT_FLAGS_PACKED,
491 .name = "8 bpp, dithered color",
492 .fourcc = V4L2_PIX_FMT_HI240,
493 .btformat = BT848_COLOR_FMT_RGB8,
494 .depth = 8,
495 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
497 .name = "15 bpp RGB, le",
498 .fourcc = V4L2_PIX_FMT_RGB555,
499 .btformat = BT848_COLOR_FMT_RGB15,
500 .depth = 16,
501 .flags = FORMAT_FLAGS_PACKED,
503 .name = "15 bpp RGB, be",
504 .fourcc = V4L2_PIX_FMT_RGB555X,
505 .btformat = BT848_COLOR_FMT_RGB15,
506 .btswap = 0x03, /* byteswap */
507 .depth = 16,
508 .flags = FORMAT_FLAGS_PACKED,
510 .name = "16 bpp RGB, le",
511 .fourcc = V4L2_PIX_FMT_RGB565,
512 .btformat = BT848_COLOR_FMT_RGB16,
513 .depth = 16,
514 .flags = FORMAT_FLAGS_PACKED,
516 .name = "16 bpp RGB, be",
517 .fourcc = V4L2_PIX_FMT_RGB565X,
518 .btformat = BT848_COLOR_FMT_RGB16,
519 .btswap = 0x03, /* byteswap */
520 .depth = 16,
521 .flags = FORMAT_FLAGS_PACKED,
523 .name = "24 bpp RGB, le",
524 .fourcc = V4L2_PIX_FMT_BGR24,
525 .btformat = BT848_COLOR_FMT_RGB24,
526 .depth = 24,
527 .flags = FORMAT_FLAGS_PACKED,
529 .name = "32 bpp RGB, le",
530 .fourcc = V4L2_PIX_FMT_BGR32,
531 .btformat = BT848_COLOR_FMT_RGB32,
532 .depth = 32,
533 .flags = FORMAT_FLAGS_PACKED,
535 .name = "32 bpp RGB, be",
536 .fourcc = V4L2_PIX_FMT_RGB32,
537 .btformat = BT848_COLOR_FMT_RGB32,
538 .btswap = 0x0f, /* byte+word swap */
539 .depth = 32,
540 .flags = FORMAT_FLAGS_PACKED,
542 .name = "4:2:2, packed, YUYV",
543 .fourcc = V4L2_PIX_FMT_YUYV,
544 .btformat = BT848_COLOR_FMT_YUY2,
545 .depth = 16,
546 .flags = FORMAT_FLAGS_PACKED,
548 .name = "4:2:2, packed, YUYV",
549 .fourcc = V4L2_PIX_FMT_YUYV,
550 .btformat = BT848_COLOR_FMT_YUY2,
551 .depth = 16,
552 .flags = FORMAT_FLAGS_PACKED,
554 .name = "4:2:2, packed, UYVY",
555 .fourcc = V4L2_PIX_FMT_UYVY,
556 .btformat = BT848_COLOR_FMT_YUY2,
557 .btswap = 0x03, /* byteswap */
558 .depth = 16,
559 .flags = FORMAT_FLAGS_PACKED,
561 .name = "4:2:2, planar, Y-Cb-Cr",
562 .fourcc = V4L2_PIX_FMT_YUV422P,
563 .btformat = BT848_COLOR_FMT_YCrCb422,
564 .depth = 16,
565 .flags = FORMAT_FLAGS_PLANAR,
566 .hshift = 1,
567 .vshift = 0,
569 .name = "4:2:0, planar, Y-Cb-Cr",
570 .fourcc = V4L2_PIX_FMT_YUV420,
571 .btformat = BT848_COLOR_FMT_YCrCb422,
572 .depth = 12,
573 .flags = FORMAT_FLAGS_PLANAR,
574 .hshift = 1,
575 .vshift = 1,
577 .name = "4:2:0, planar, Y-Cr-Cb",
578 .fourcc = V4L2_PIX_FMT_YVU420,
579 .btformat = BT848_COLOR_FMT_YCrCb422,
580 .depth = 12,
581 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
582 .hshift = 1,
583 .vshift = 1,
585 .name = "4:1:1, planar, Y-Cb-Cr",
586 .fourcc = V4L2_PIX_FMT_YUV411P,
587 .btformat = BT848_COLOR_FMT_YCrCb411,
588 .depth = 12,
589 .flags = FORMAT_FLAGS_PLANAR,
590 .hshift = 2,
591 .vshift = 0,
593 .name = "4:1:0, planar, Y-Cb-Cr",
594 .fourcc = V4L2_PIX_FMT_YUV410,
595 .btformat = BT848_COLOR_FMT_YCrCb411,
596 .depth = 9,
597 .flags = FORMAT_FLAGS_PLANAR,
598 .hshift = 2,
599 .vshift = 2,
601 .name = "4:1:0, planar, Y-Cr-Cb",
602 .fourcc = V4L2_PIX_FMT_YVU410,
603 .btformat = BT848_COLOR_FMT_YCrCb411,
604 .depth = 9,
605 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
606 .hshift = 2,
607 .vshift = 2,
609 .name = "raw scanlines",
610 .fourcc = -1,
611 .btformat = BT848_COLOR_FMT_RAW,
612 .depth = 8,
613 .flags = FORMAT_FLAGS_RAW,
616 static const unsigned int FORMATS = ARRAY_SIZE(formats);
618 /* ----------------------------------------------------------------------- */
620 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
621 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
622 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
623 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
624 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
625 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
626 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
627 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
628 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
629 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
630 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
631 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
633 static const struct v4l2_queryctrl no_ctl = {
634 .name = "42",
635 .flags = V4L2_CTRL_FLAG_DISABLED,
637 static const struct v4l2_queryctrl bttv_ctls[] = {
638 /* --- video --- */
640 .id = V4L2_CID_BRIGHTNESS,
641 .name = "Brightness",
642 .minimum = 0,
643 .maximum = 65535,
644 .step = 256,
645 .default_value = 32768,
646 .type = V4L2_CTRL_TYPE_INTEGER,
648 .id = V4L2_CID_CONTRAST,
649 .name = "Contrast",
650 .minimum = 0,
651 .maximum = 65535,
652 .step = 128,
653 .default_value = 32768,
654 .type = V4L2_CTRL_TYPE_INTEGER,
656 .id = V4L2_CID_SATURATION,
657 .name = "Saturation",
658 .minimum = 0,
659 .maximum = 65535,
660 .step = 128,
661 .default_value = 32768,
662 .type = V4L2_CTRL_TYPE_INTEGER,
664 .id = V4L2_CID_HUE,
665 .name = "Hue",
666 .minimum = 0,
667 .maximum = 65535,
668 .step = 256,
669 .default_value = 32768,
670 .type = V4L2_CTRL_TYPE_INTEGER,
672 /* --- audio --- */
674 .id = V4L2_CID_AUDIO_MUTE,
675 .name = "Mute",
676 .minimum = 0,
677 .maximum = 1,
678 .type = V4L2_CTRL_TYPE_BOOLEAN,
680 .id = V4L2_CID_AUDIO_VOLUME,
681 .name = "Volume",
682 .minimum = 0,
683 .maximum = 65535,
684 .step = 65535/100,
685 .default_value = 65535,
686 .type = V4L2_CTRL_TYPE_INTEGER,
688 .id = V4L2_CID_AUDIO_BALANCE,
689 .name = "Balance",
690 .minimum = 0,
691 .maximum = 65535,
692 .step = 65535/100,
693 .default_value = 32768,
694 .type = V4L2_CTRL_TYPE_INTEGER,
696 .id = V4L2_CID_AUDIO_BASS,
697 .name = "Bass",
698 .minimum = 0,
699 .maximum = 65535,
700 .step = 65535/100,
701 .default_value = 32768,
702 .type = V4L2_CTRL_TYPE_INTEGER,
704 .id = V4L2_CID_AUDIO_TREBLE,
705 .name = "Treble",
706 .minimum = 0,
707 .maximum = 65535,
708 .step = 65535/100,
709 .default_value = 32768,
710 .type = V4L2_CTRL_TYPE_INTEGER,
712 /* --- private --- */
714 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
715 .name = "chroma agc",
716 .minimum = 0,
717 .maximum = 1,
718 .type = V4L2_CTRL_TYPE_BOOLEAN,
720 .id = V4L2_CID_PRIVATE_COMBFILTER,
721 .name = "combfilter",
722 .minimum = 0,
723 .maximum = 1,
724 .type = V4L2_CTRL_TYPE_BOOLEAN,
726 .id = V4L2_CID_PRIVATE_AUTOMUTE,
727 .name = "automute",
728 .minimum = 0,
729 .maximum = 1,
730 .type = V4L2_CTRL_TYPE_BOOLEAN,
732 .id = V4L2_CID_PRIVATE_LUMAFILTER,
733 .name = "luma decimation filter",
734 .minimum = 0,
735 .maximum = 1,
736 .type = V4L2_CTRL_TYPE_BOOLEAN,
738 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
739 .name = "agc crush",
740 .minimum = 0,
741 .maximum = 1,
742 .type = V4L2_CTRL_TYPE_BOOLEAN,
744 .id = V4L2_CID_PRIVATE_VCR_HACK,
745 .name = "vcr hack",
746 .minimum = 0,
747 .maximum = 1,
748 .type = V4L2_CTRL_TYPE_BOOLEAN,
750 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
751 .name = "whitecrush upper",
752 .minimum = 0,
753 .maximum = 255,
754 .step = 1,
755 .default_value = 0xCF,
756 .type = V4L2_CTRL_TYPE_INTEGER,
758 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
759 .name = "whitecrush lower",
760 .minimum = 0,
761 .maximum = 255,
762 .step = 1,
763 .default_value = 0x7F,
764 .type = V4L2_CTRL_TYPE_INTEGER,
766 .id = V4L2_CID_PRIVATE_UV_RATIO,
767 .name = "uv ratio",
768 .minimum = 0,
769 .maximum = 100,
770 .step = 1,
771 .default_value = 50,
772 .type = V4L2_CTRL_TYPE_INTEGER,
774 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
775 .name = "full luma range",
776 .minimum = 0,
777 .maximum = 1,
778 .type = V4L2_CTRL_TYPE_BOOLEAN,
780 .id = V4L2_CID_PRIVATE_CORING,
781 .name = "coring",
782 .minimum = 0,
783 .maximum = 3,
784 .step = 1,
785 .default_value = 0,
786 .type = V4L2_CTRL_TYPE_INTEGER,
793 static const struct v4l2_queryctrl *ctrl_by_id(int id)
795 int i;
797 for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
798 if (bttv_ctls[i].id == id)
799 return bttv_ctls+i;
801 return NULL;
804 /* ----------------------------------------------------------------------- */
805 /* resource management */
808 RESOURCE_ allocated by freed by
810 VIDEO_READ bttv_read 1) bttv_read 2)
812 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
813 VIDIOC_QBUF 1) bttv_release
814 VIDIOCMCAPTURE 1)
816 OVERLAY VIDIOCCAPTURE on VIDIOCCAPTURE off
817 VIDIOC_OVERLAY on VIDIOC_OVERLAY off
818 3) bttv_release
820 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
821 VIDIOC_QBUF 1) bttv_release
822 bttv_read, bttv_poll 1) 4)
824 1) The resource must be allocated when we enter buffer prepare functions
825 and remain allocated while buffers are in the DMA queue.
826 2) This is a single frame read.
827 3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
828 RESOURCE_OVERLAY is allocated.
829 4) This is a continuous read, implies VIDIOC_STREAMON.
831 Note this driver permits video input and standard changes regardless if
832 resources are allocated.
835 #define VBI_RESOURCES (RESOURCE_VBI)
836 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
837 RESOURCE_VIDEO_STREAM | \
838 RESOURCE_OVERLAY)
840 static
841 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
843 int xbits; /* mutual exclusive resources */
845 if (fh->resources & bit)
846 /* have it already allocated */
847 return 1;
849 xbits = bit;
850 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
851 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
853 /* is it free? */
854 mutex_lock(&btv->lock);
855 if (btv->resources & xbits) {
856 /* no, someone else uses it */
857 goto fail;
860 if ((bit & VIDEO_RESOURCES)
861 && 0 == (btv->resources & VIDEO_RESOURCES)) {
862 /* Do crop - use current, don't - use default parameters. */
863 __s32 top = btv->crop[!!fh->do_crop].rect.top;
865 if (btv->vbi_end > top)
866 goto fail;
868 /* We cannot capture the same line as video and VBI data.
869 Claim scan lines crop[].rect.top to bottom. */
870 btv->crop_start = top;
871 } else if (bit & VBI_RESOURCES) {
872 __s32 end = fh->vbi_fmt.end;
874 if (end > btv->crop_start)
875 goto fail;
877 /* Claim scan lines above fh->vbi_fmt.end. */
878 btv->vbi_end = end;
881 /* it's free, grab it */
882 fh->resources |= bit;
883 btv->resources |= bit;
884 mutex_unlock(&btv->lock);
885 return 1;
887 fail:
888 mutex_unlock(&btv->lock);
889 return 0;
892 static
893 int check_btres(struct bttv_fh *fh, int bit)
895 return (fh->resources & bit);
898 static
899 int locked_btres(struct bttv *btv, int bit)
901 return (btv->resources & bit);
904 /* Call with btv->lock down. */
905 static void
906 disclaim_vbi_lines(struct bttv *btv)
908 btv->vbi_end = 0;
911 /* Call with btv->lock down. */
912 static void
913 disclaim_video_lines(struct bttv *btv)
915 const struct bttv_tvnorm *tvnorm;
916 u8 crop;
918 tvnorm = &bttv_tvnorms[btv->tvnorm];
919 btv->crop_start = tvnorm->cropcap.bounds.top
920 + tvnorm->cropcap.bounds.height;
922 /* VBI capturing ends at VDELAY, start of video capturing, no
923 matter how many lines the VBI RISC program expects. When video
924 capturing is off, it shall no longer "preempt" VBI capturing,
925 so we set VDELAY to maximum. */
926 crop = btread(BT848_E_CROP) | 0xc0;
927 btwrite(crop, BT848_E_CROP);
928 btwrite(0xfe, BT848_E_VDELAY_LO);
929 btwrite(crop, BT848_O_CROP);
930 btwrite(0xfe, BT848_O_VDELAY_LO);
933 static
934 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
936 if ((fh->resources & bits) != bits) {
937 /* trying to free ressources not allocated by us ... */
938 printk("bttv: BUG! (btres)\n");
940 mutex_lock(&btv->lock);
941 fh->resources &= ~bits;
942 btv->resources &= ~bits;
944 bits = btv->resources;
946 if (0 == (bits & VIDEO_RESOURCES))
947 disclaim_video_lines(btv);
949 if (0 == (bits & VBI_RESOURCES))
950 disclaim_vbi_lines(btv);
952 mutex_unlock(&btv->lock);
955 /* ----------------------------------------------------------------------- */
956 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
958 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
959 PLL_X = Reference pre-divider (0=1, 1=2)
960 PLL_C = Post divider (0=6, 1=4)
961 PLL_I = Integer input
962 PLL_F = Fractional input
964 F_input = 28.636363 MHz:
965 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
968 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
970 unsigned char fl, fh, fi;
972 /* prevent overflows */
973 fin/=4;
974 fout/=4;
976 fout*=12;
977 fi=fout/fin;
979 fout=(fout%fin)*256;
980 fh=fout/fin;
982 fout=(fout%fin)*256;
983 fl=fout/fin;
985 btwrite(fl, BT848_PLL_F_LO);
986 btwrite(fh, BT848_PLL_F_HI);
987 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
990 static void set_pll(struct bttv *btv)
992 int i;
994 if (!btv->pll.pll_crystal)
995 return;
997 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
998 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
999 return;
1002 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
1003 /* no PLL needed */
1004 if (btv->pll.pll_current == 0)
1005 return;
1006 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
1007 btv->c.nr,btv->pll.pll_ifreq);
1008 btwrite(0x00,BT848_TGCTRL);
1009 btwrite(0x00,BT848_PLL_XCI);
1010 btv->pll.pll_current = 0;
1011 return;
1014 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
1015 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1016 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1018 for (i=0; i<10; i++) {
1019 /* Let other people run while the PLL stabilizes */
1020 bttv_printk(".");
1021 msleep(10);
1023 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1024 btwrite(0,BT848_DSTATUS);
1025 } else {
1026 btwrite(0x08,BT848_TGCTRL);
1027 btv->pll.pll_current = btv->pll.pll_ofreq;
1028 bttv_printk(" ok\n");
1029 return;
1032 btv->pll.pll_current = -1;
1033 bttv_printk("failed\n");
1034 return;
1037 /* used to switch between the bt848's analog/digital video capture modes */
1038 static void bt848A_set_timing(struct bttv *btv)
1040 int i, len;
1041 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1042 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
1044 if (btv->input == btv->dig) {
1045 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1046 btv->c.nr,table_idx);
1048 /* timing change...reset timing generator address */
1049 btwrite(0x00, BT848_TGCTRL);
1050 btwrite(0x02, BT848_TGCTRL);
1051 btwrite(0x00, BT848_TGCTRL);
1053 len=SRAM_Table[table_idx][0];
1054 for(i = 1; i <= len; i++)
1055 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1056 btv->pll.pll_ofreq = 27000000;
1058 set_pll(btv);
1059 btwrite(0x11, BT848_TGCTRL);
1060 btwrite(0x41, BT848_DVSIF);
1061 } else {
1062 btv->pll.pll_ofreq = fsc;
1063 set_pll(btv);
1064 btwrite(0x0, BT848_DVSIF);
1068 /* ----------------------------------------------------------------------- */
1070 static void bt848_bright(struct bttv *btv, int bright)
1072 int value;
1074 // printk("bttv: set bright: %d\n",bright); // DEBUG
1075 btv->bright = bright;
1077 /* We want -128 to 127 we get 0-65535 */
1078 value = (bright >> 8) - 128;
1079 btwrite(value & 0xff, BT848_BRIGHT);
1082 static void bt848_hue(struct bttv *btv, int hue)
1084 int value;
1086 btv->hue = hue;
1088 /* -128 to 127 */
1089 value = (hue >> 8) - 128;
1090 btwrite(value & 0xff, BT848_HUE);
1093 static void bt848_contrast(struct bttv *btv, int cont)
1095 int value,hibit;
1097 btv->contrast = cont;
1099 /* 0-511 */
1100 value = (cont >> 7);
1101 hibit = (value >> 6) & 4;
1102 btwrite(value & 0xff, BT848_CONTRAST_LO);
1103 btaor(hibit, ~4, BT848_E_CONTROL);
1104 btaor(hibit, ~4, BT848_O_CONTROL);
1107 static void bt848_sat(struct bttv *btv, int color)
1109 int val_u,val_v,hibits;
1111 btv->saturation = color;
1113 /* 0-511 for the color */
1114 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
1115 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1116 hibits = (val_u >> 7) & 2;
1117 hibits |= (val_v >> 8) & 1;
1118 btwrite(val_u & 0xff, BT848_SAT_U_LO);
1119 btwrite(val_v & 0xff, BT848_SAT_V_LO);
1120 btaor(hibits, ~3, BT848_E_CONTROL);
1121 btaor(hibits, ~3, BT848_O_CONTROL);
1124 /* ----------------------------------------------------------------------- */
1126 static int
1127 video_mux(struct bttv *btv, unsigned int input)
1129 int mux,mask2;
1131 if (input >= bttv_tvcards[btv->c.type].video_inputs)
1132 return -EINVAL;
1134 /* needed by RemoteVideo MX */
1135 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1136 if (mask2)
1137 gpio_inout(mask2,mask2);
1139 if (input == btv->svhs) {
1140 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1141 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1142 } else {
1143 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1144 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1146 mux = bttv_muxsel(btv, input);
1147 btaor(mux<<5, ~(3<<5), BT848_IFORM);
1148 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1149 btv->c.nr,input,mux);
1151 /* card specific hook */
1152 if(bttv_tvcards[btv->c.type].muxsel_hook)
1153 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1154 return 0;
1157 static char *audio_modes[] = {
1158 "audio: tuner", "audio: radio", "audio: extern",
1159 "audio: intern", "audio: mute"
1162 static int
1163 audio_mux(struct bttv *btv, int input, int mute)
1165 int gpio_val, signal;
1166 struct v4l2_control ctrl;
1168 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1169 bttv_tvcards[btv->c.type].gpiomask);
1170 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1172 btv->mute = mute;
1173 btv->audio = input;
1175 /* automute */
1176 mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1178 if (mute)
1179 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1180 else
1181 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1183 switch (btv->c.type) {
1184 case BTTV_BOARD_VOODOOTV_FM:
1185 case BTTV_BOARD_VOODOOTV_200:
1186 gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
1187 break;
1189 default:
1190 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1193 if (bttv_gpio)
1194 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1195 if (in_interrupt())
1196 return 0;
1198 ctrl.id = V4L2_CID_AUDIO_MUTE;
1199 ctrl.value = btv->mute;
1200 bttv_call_all(btv, core, s_ctrl, &ctrl);
1201 if (btv->sd_msp34xx) {
1202 u32 in;
1204 /* Note: the inputs tuner/radio/extern/intern are translated
1205 to msp routings. This assumes common behavior for all msp3400
1206 based TV cards. When this assumption fails, then the
1207 specific MSP routing must be added to the card table.
1208 For now this is sufficient. */
1209 switch (input) {
1210 case TVAUDIO_INPUT_RADIO:
1211 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1212 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1213 break;
1214 case TVAUDIO_INPUT_EXTERN:
1215 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1216 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1217 break;
1218 case TVAUDIO_INPUT_INTERN:
1219 /* Yes, this is the same input as for RADIO. I doubt
1220 if this is ever used. The only board with an INTERN
1221 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1222 that was tested. My guess is that the whole INTERN
1223 input does not work. */
1224 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1225 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1226 break;
1227 case TVAUDIO_INPUT_TUNER:
1228 default:
1229 /* This is the only card that uses TUNER2, and afaik,
1230 is the only difference between the VOODOOTV_FM
1231 and VOODOOTV_200 */
1232 if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1233 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1234 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1235 else
1236 in = MSP_INPUT_DEFAULT;
1237 break;
1239 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1240 in, MSP_OUTPUT_DEFAULT, 0);
1242 if (btv->sd_tvaudio) {
1243 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1244 input, 0, 0);
1246 return 0;
1249 static inline int
1250 audio_mute(struct bttv *btv, int mute)
1252 return audio_mux(btv, btv->audio, mute);
1255 static inline int
1256 audio_input(struct bttv *btv, int input)
1258 return audio_mux(btv, input, btv->mute);
1261 static void
1262 bttv_crop_calc_limits(struct bttv_crop *c)
1264 /* Scale factor min. 1:1, max. 16:1. Min. image size
1265 48 x 32. Scaled width must be a multiple of 4. */
1267 if (1) {
1268 /* For bug compatibility with VIDIOCGCAP and image
1269 size checks in earlier driver versions. */
1270 c->min_scaled_width = 48;
1271 c->min_scaled_height = 32;
1272 } else {
1273 c->min_scaled_width =
1274 (max(48, c->rect.width >> 4) + 3) & ~3;
1275 c->min_scaled_height =
1276 max(32, c->rect.height >> 4);
1279 c->max_scaled_width = c->rect.width & ~3;
1280 c->max_scaled_height = c->rect.height;
1283 static void
1284 bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1286 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1287 bttv_crop_calc_limits(c);
1290 /* Call with btv->lock down. */
1291 static int
1292 set_tvnorm(struct bttv *btv, unsigned int norm)
1294 const struct bttv_tvnorm *tvnorm;
1295 v4l2_std_id id;
1297 BUG_ON(norm >= BTTV_TVNORMS);
1298 BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
1300 tvnorm = &bttv_tvnorms[norm];
1302 if (!memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1303 sizeof (tvnorm->cropcap))) {
1304 bttv_crop_reset(&btv->crop[0], norm);
1305 btv->crop[1] = btv->crop[0]; /* current = default */
1307 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1308 btv->crop_start = tvnorm->cropcap.bounds.top
1309 + tvnorm->cropcap.bounds.height;
1313 btv->tvnorm = norm;
1315 btwrite(tvnorm->adelay, BT848_ADELAY);
1316 btwrite(tvnorm->bdelay, BT848_BDELAY);
1317 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1318 BT848_IFORM);
1319 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1320 btwrite(1, BT848_VBI_PACK_DEL);
1321 bt848A_set_timing(btv);
1323 switch (btv->c.type) {
1324 case BTTV_BOARD_VOODOOTV_FM:
1325 case BTTV_BOARD_VOODOOTV_200:
1326 bttv_tda9880_setnorm(btv, gpio_read());
1327 break;
1329 id = tvnorm->v4l2_id;
1330 bttv_call_all(btv, core, s_std, id);
1332 return 0;
1335 /* Call with btv->lock down. */
1336 static void
1337 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1339 unsigned long flags;
1341 btv->input = input;
1342 if (irq_iswitch) {
1343 spin_lock_irqsave(&btv->s_lock,flags);
1344 if (btv->curr.frame_irq) {
1345 /* active capture -> delayed input switch */
1346 btv->new_input = input;
1347 } else {
1348 video_mux(btv,input);
1350 spin_unlock_irqrestore(&btv->s_lock,flags);
1351 } else {
1352 video_mux(btv,input);
1354 audio_input(btv, (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1355 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN);
1356 set_tvnorm(btv, norm);
1359 static void init_irqreg(struct bttv *btv)
1361 /* clear status */
1362 btwrite(0xfffffUL, BT848_INT_STAT);
1364 if (bttv_tvcards[btv->c.type].no_video) {
1365 /* i2c only */
1366 btwrite(BT848_INT_I2CDONE,
1367 BT848_INT_MASK);
1368 } else {
1369 /* full video */
1370 btwrite((btv->triton1) |
1371 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1372 BT848_INT_SCERR |
1373 (fdsr ? BT848_INT_FDSR : 0) |
1374 BT848_INT_RISCI | BT848_INT_OCERR |
1375 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1376 BT848_INT_I2CDONE,
1377 BT848_INT_MASK);
1381 static void init_bt848(struct bttv *btv)
1383 int val;
1385 if (bttv_tvcards[btv->c.type].no_video) {
1386 /* very basic init only */
1387 init_irqreg(btv);
1388 return;
1391 btwrite(0x00, BT848_CAP_CTL);
1392 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1393 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1395 /* set planar and packed mode trigger points and */
1396 /* set rising edge of inverted GPINTR pin as irq trigger */
1397 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1398 BT848_GPIO_DMA_CTL_PLTP1_16|
1399 BT848_GPIO_DMA_CTL_PLTP23_16|
1400 BT848_GPIO_DMA_CTL_GPINTC|
1401 BT848_GPIO_DMA_CTL_GPINTI,
1402 BT848_GPIO_DMA_CTL);
1404 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1405 btwrite(val, BT848_E_SCLOOP);
1406 btwrite(val, BT848_O_SCLOOP);
1408 btwrite(0x20, BT848_E_VSCALE_HI);
1409 btwrite(0x20, BT848_O_VSCALE_HI);
1410 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1411 BT848_ADC);
1413 btwrite(whitecrush_upper, BT848_WC_UP);
1414 btwrite(whitecrush_lower, BT848_WC_DOWN);
1416 if (btv->opt_lumafilter) {
1417 btwrite(0, BT848_E_CONTROL);
1418 btwrite(0, BT848_O_CONTROL);
1419 } else {
1420 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1421 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1424 bt848_bright(btv, btv->bright);
1425 bt848_hue(btv, btv->hue);
1426 bt848_contrast(btv, btv->contrast);
1427 bt848_sat(btv, btv->saturation);
1429 /* interrupt */
1430 init_irqreg(btv);
1433 static void bttv_reinit_bt848(struct bttv *btv)
1435 unsigned long flags;
1437 if (bttv_verbose)
1438 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1439 spin_lock_irqsave(&btv->s_lock,flags);
1440 btv->errors=0;
1441 bttv_set_dma(btv,0);
1442 spin_unlock_irqrestore(&btv->s_lock,flags);
1444 init_bt848(btv);
1445 btv->pll.pll_current = -1;
1446 set_input(btv, btv->input, btv->tvnorm);
1449 static int bttv_g_ctrl(struct file *file, void *priv,
1450 struct v4l2_control *c)
1452 struct bttv_fh *fh = priv;
1453 struct bttv *btv = fh->btv;
1455 switch (c->id) {
1456 case V4L2_CID_BRIGHTNESS:
1457 c->value = btv->bright;
1458 break;
1459 case V4L2_CID_HUE:
1460 c->value = btv->hue;
1461 break;
1462 case V4L2_CID_CONTRAST:
1463 c->value = btv->contrast;
1464 break;
1465 case V4L2_CID_SATURATION:
1466 c->value = btv->saturation;
1467 break;
1469 case V4L2_CID_AUDIO_MUTE:
1470 case V4L2_CID_AUDIO_VOLUME:
1471 case V4L2_CID_AUDIO_BALANCE:
1472 case V4L2_CID_AUDIO_BASS:
1473 case V4L2_CID_AUDIO_TREBLE:
1474 bttv_call_all(btv, core, g_ctrl, c);
1475 break;
1477 case V4L2_CID_PRIVATE_CHROMA_AGC:
1478 c->value = btv->opt_chroma_agc;
1479 break;
1480 case V4L2_CID_PRIVATE_COMBFILTER:
1481 c->value = btv->opt_combfilter;
1482 break;
1483 case V4L2_CID_PRIVATE_LUMAFILTER:
1484 c->value = btv->opt_lumafilter;
1485 break;
1486 case V4L2_CID_PRIVATE_AUTOMUTE:
1487 c->value = btv->opt_automute;
1488 break;
1489 case V4L2_CID_PRIVATE_AGC_CRUSH:
1490 c->value = btv->opt_adc_crush;
1491 break;
1492 case V4L2_CID_PRIVATE_VCR_HACK:
1493 c->value = btv->opt_vcr_hack;
1494 break;
1495 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1496 c->value = btv->opt_whitecrush_upper;
1497 break;
1498 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1499 c->value = btv->opt_whitecrush_lower;
1500 break;
1501 case V4L2_CID_PRIVATE_UV_RATIO:
1502 c->value = btv->opt_uv_ratio;
1503 break;
1504 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1505 c->value = btv->opt_full_luma_range;
1506 break;
1507 case V4L2_CID_PRIVATE_CORING:
1508 c->value = btv->opt_coring;
1509 break;
1510 default:
1511 return -EINVAL;
1513 return 0;
1516 static int bttv_s_ctrl(struct file *file, void *f,
1517 struct v4l2_control *c)
1519 int err;
1520 int val;
1521 struct bttv_fh *fh = f;
1522 struct bttv *btv = fh->btv;
1524 err = v4l2_prio_check(&btv->prio, &fh->prio);
1525 if (0 != err)
1526 return err;
1528 switch (c->id) {
1529 case V4L2_CID_BRIGHTNESS:
1530 bt848_bright(btv, c->value);
1531 break;
1532 case V4L2_CID_HUE:
1533 bt848_hue(btv, c->value);
1534 break;
1535 case V4L2_CID_CONTRAST:
1536 bt848_contrast(btv, c->value);
1537 break;
1538 case V4L2_CID_SATURATION:
1539 bt848_sat(btv, c->value);
1540 break;
1541 case V4L2_CID_AUDIO_MUTE:
1542 audio_mute(btv, c->value);
1543 /* fall through */
1544 case V4L2_CID_AUDIO_VOLUME:
1545 if (btv->volume_gpio)
1546 btv->volume_gpio(btv, c->value);
1548 bttv_call_all(btv, core, s_ctrl, c);
1549 break;
1550 case V4L2_CID_AUDIO_BALANCE:
1551 case V4L2_CID_AUDIO_BASS:
1552 case V4L2_CID_AUDIO_TREBLE:
1553 bttv_call_all(btv, core, s_ctrl, c);
1554 break;
1556 case V4L2_CID_PRIVATE_CHROMA_AGC:
1557 btv->opt_chroma_agc = c->value;
1558 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1559 btwrite(val, BT848_E_SCLOOP);
1560 btwrite(val, BT848_O_SCLOOP);
1561 break;
1562 case V4L2_CID_PRIVATE_COMBFILTER:
1563 btv->opt_combfilter = c->value;
1564 break;
1565 case V4L2_CID_PRIVATE_LUMAFILTER:
1566 btv->opt_lumafilter = c->value;
1567 if (btv->opt_lumafilter) {
1568 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1569 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1570 } else {
1571 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1572 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1574 break;
1575 case V4L2_CID_PRIVATE_AUTOMUTE:
1576 btv->opt_automute = c->value;
1577 break;
1578 case V4L2_CID_PRIVATE_AGC_CRUSH:
1579 btv->opt_adc_crush = c->value;
1580 btwrite(BT848_ADC_RESERVED |
1581 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1582 BT848_ADC);
1583 break;
1584 case V4L2_CID_PRIVATE_VCR_HACK:
1585 btv->opt_vcr_hack = c->value;
1586 break;
1587 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1588 btv->opt_whitecrush_upper = c->value;
1589 btwrite(c->value, BT848_WC_UP);
1590 break;
1591 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1592 btv->opt_whitecrush_lower = c->value;
1593 btwrite(c->value, BT848_WC_DOWN);
1594 break;
1595 case V4L2_CID_PRIVATE_UV_RATIO:
1596 btv->opt_uv_ratio = c->value;
1597 bt848_sat(btv, btv->saturation);
1598 break;
1599 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1600 btv->opt_full_luma_range = c->value;
1601 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1602 break;
1603 case V4L2_CID_PRIVATE_CORING:
1604 btv->opt_coring = c->value;
1605 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1606 break;
1607 default:
1608 return -EINVAL;
1610 return 0;
1613 /* ----------------------------------------------------------------------- */
1615 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1617 unsigned int outbits, data;
1618 outbits = btread(BT848_GPIO_OUT_EN);
1619 data = btread(BT848_GPIO_DATA);
1620 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1621 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1624 static void bttv_field_count(struct bttv *btv)
1626 int need_count = 0;
1628 if (btv->users)
1629 need_count++;
1631 if (need_count) {
1632 /* start field counter */
1633 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1634 } else {
1635 /* stop field counter */
1636 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1637 btv->field_count = 0;
1641 static const struct bttv_format*
1642 format_by_fourcc(int fourcc)
1644 unsigned int i;
1646 for (i = 0; i < FORMATS; i++) {
1647 if (-1 == formats[i].fourcc)
1648 continue;
1649 if (formats[i].fourcc == fourcc)
1650 return formats+i;
1652 return NULL;
1655 /* ----------------------------------------------------------------------- */
1656 /* misc helpers */
1658 static int
1659 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1660 struct bttv_buffer *new)
1662 struct bttv_buffer *old;
1663 unsigned long flags;
1664 int retval = 0;
1666 dprintk("switch_overlay: enter [new=%p]\n",new);
1667 if (new)
1668 new->vb.state = VIDEOBUF_DONE;
1669 spin_lock_irqsave(&btv->s_lock,flags);
1670 old = btv->screen;
1671 btv->screen = new;
1672 btv->loop_irq |= 1;
1673 bttv_set_dma(btv, 0x03);
1674 spin_unlock_irqrestore(&btv->s_lock,flags);
1675 if (NULL != old) {
1676 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1677 bttv_dma_free(&fh->cap,btv, old);
1678 kfree(old);
1680 if (NULL == new)
1681 free_btres(btv,fh,RESOURCE_OVERLAY);
1682 dprintk("switch_overlay: done\n");
1683 return retval;
1686 /* ----------------------------------------------------------------------- */
1687 /* video4linux (1) interface */
1689 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1690 struct bttv_buffer *buf,
1691 const struct bttv_format *fmt,
1692 unsigned int width, unsigned int height,
1693 enum v4l2_field field)
1695 struct bttv_fh *fh = q->priv_data;
1696 int redo_dma_risc = 0;
1697 struct bttv_crop c;
1698 int norm;
1699 int rc;
1701 /* check settings */
1702 if (NULL == fmt)
1703 return -EINVAL;
1704 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1705 width = RAW_BPL;
1706 height = RAW_LINES*2;
1707 if (width*height > buf->vb.bsize)
1708 return -EINVAL;
1709 buf->vb.size = buf->vb.bsize;
1711 /* Make sure tvnorm and vbi_end remain consistent
1712 until we're done. */
1713 mutex_lock(&btv->lock);
1715 norm = btv->tvnorm;
1717 /* In this mode capturing always starts at defrect.top
1718 (default VDELAY), ignoring cropping parameters. */
1719 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1720 mutex_unlock(&btv->lock);
1721 return -EINVAL;
1724 mutex_unlock(&btv->lock);
1726 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1727 } else {
1728 mutex_lock(&btv->lock);
1730 norm = btv->tvnorm;
1731 c = btv->crop[!!fh->do_crop];
1733 mutex_unlock(&btv->lock);
1735 if (width < c.min_scaled_width ||
1736 width > c.max_scaled_width ||
1737 height < c.min_scaled_height)
1738 return -EINVAL;
1740 switch (field) {
1741 case V4L2_FIELD_TOP:
1742 case V4L2_FIELD_BOTTOM:
1743 case V4L2_FIELD_ALTERNATE:
1744 /* btv->crop counts frame lines. Max. scale
1745 factor is 16:1 for frames, 8:1 for fields. */
1746 if (height * 2 > c.max_scaled_height)
1747 return -EINVAL;
1748 break;
1750 default:
1751 if (height > c.max_scaled_height)
1752 return -EINVAL;
1753 break;
1756 buf->vb.size = (width * height * fmt->depth) >> 3;
1757 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1758 return -EINVAL;
1761 /* alloc + fill struct bttv_buffer (if changed) */
1762 if (buf->vb.width != width || buf->vb.height != height ||
1763 buf->vb.field != field ||
1764 buf->tvnorm != norm || buf->fmt != fmt ||
1765 buf->crop.top != c.rect.top ||
1766 buf->crop.left != c.rect.left ||
1767 buf->crop.width != c.rect.width ||
1768 buf->crop.height != c.rect.height) {
1769 buf->vb.width = width;
1770 buf->vb.height = height;
1771 buf->vb.field = field;
1772 buf->tvnorm = norm;
1773 buf->fmt = fmt;
1774 buf->crop = c.rect;
1775 redo_dma_risc = 1;
1778 /* alloc risc memory */
1779 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1780 redo_dma_risc = 1;
1781 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1782 goto fail;
1785 if (redo_dma_risc)
1786 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1787 goto fail;
1789 buf->vb.state = VIDEOBUF_PREPARED;
1790 return 0;
1792 fail:
1793 bttv_dma_free(q,btv,buf);
1794 return rc;
1797 static int
1798 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1800 struct bttv_fh *fh = q->priv_data;
1802 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1803 if (0 == *count)
1804 *count = gbuffers;
1805 while (*size * *count > gbuffers * gbufsize)
1806 (*count)--;
1807 return 0;
1810 static int
1811 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1812 enum v4l2_field field)
1814 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1815 struct bttv_fh *fh = q->priv_data;
1817 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1818 fh->width, fh->height, field);
1821 static void
1822 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1824 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1825 struct bttv_fh *fh = q->priv_data;
1826 struct bttv *btv = fh->btv;
1828 buf->vb.state = VIDEOBUF_QUEUED;
1829 list_add_tail(&buf->vb.queue,&btv->capture);
1830 if (!btv->curr.frame_irq) {
1831 btv->loop_irq |= 1;
1832 bttv_set_dma(btv, 0x03);
1836 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1838 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1839 struct bttv_fh *fh = q->priv_data;
1841 bttv_dma_free(q,fh->btv,buf);
1844 static struct videobuf_queue_ops bttv_video_qops = {
1845 .buf_setup = buffer_setup,
1846 .buf_prepare = buffer_prepare,
1847 .buf_queue = buffer_queue,
1848 .buf_release = buffer_release,
1851 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1853 struct bttv_fh *fh = priv;
1854 struct bttv *btv = fh->btv;
1855 unsigned int i;
1856 int err;
1858 err = v4l2_prio_check(&btv->prio, &fh->prio);
1859 if (0 != err)
1860 return err;
1862 for (i = 0; i < BTTV_TVNORMS; i++)
1863 if (*id & bttv_tvnorms[i].v4l2_id)
1864 break;
1865 if (i == BTTV_TVNORMS)
1866 return -EINVAL;
1868 mutex_lock(&btv->lock);
1869 set_tvnorm(btv, i);
1870 mutex_unlock(&btv->lock);
1872 return 0;
1875 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1877 struct bttv_fh *fh = f;
1878 struct bttv *btv = fh->btv;
1880 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1881 *id = V4L2_STD_625_50;
1882 else
1883 *id = V4L2_STD_525_60;
1884 return 0;
1887 static int bttv_enum_input(struct file *file, void *priv,
1888 struct v4l2_input *i)
1890 struct bttv_fh *fh = priv;
1891 struct bttv *btv = fh->btv;
1892 int n;
1894 if (i->index >= bttv_tvcards[btv->c.type].video_inputs)
1895 return -EINVAL;
1897 i->type = V4L2_INPUT_TYPE_CAMERA;
1898 i->audioset = 1;
1900 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1901 sprintf(i->name, "Television");
1902 i->type = V4L2_INPUT_TYPE_TUNER;
1903 i->tuner = 0;
1904 } else if (i->index == btv->svhs) {
1905 sprintf(i->name, "S-Video");
1906 } else {
1907 sprintf(i->name, "Composite%d", i->index);
1910 if (i->index == btv->input) {
1911 __u32 dstatus = btread(BT848_DSTATUS);
1912 if (0 == (dstatus & BT848_DSTATUS_PRES))
1913 i->status |= V4L2_IN_ST_NO_SIGNAL;
1914 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1915 i->status |= V4L2_IN_ST_NO_H_LOCK;
1918 for (n = 0; n < BTTV_TVNORMS; n++)
1919 i->std |= bttv_tvnorms[n].v4l2_id;
1921 return 0;
1924 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1926 struct bttv_fh *fh = priv;
1927 struct bttv *btv = fh->btv;
1929 *i = btv->input;
1930 return 0;
1933 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1935 struct bttv_fh *fh = priv;
1936 struct bttv *btv = fh->btv;
1938 int err;
1940 err = v4l2_prio_check(&btv->prio, &fh->prio);
1941 if (0 != err)
1942 return err;
1944 if (i > bttv_tvcards[btv->c.type].video_inputs)
1945 return -EINVAL;
1947 mutex_lock(&btv->lock);
1948 set_input(btv, i, btv->tvnorm);
1949 mutex_unlock(&btv->lock);
1950 return 0;
1953 static int bttv_s_tuner(struct file *file, void *priv,
1954 struct v4l2_tuner *t)
1956 struct bttv_fh *fh = priv;
1957 struct bttv *btv = fh->btv;
1958 int err;
1960 err = v4l2_prio_check(&btv->prio, &fh->prio);
1961 if (0 != err)
1962 return err;
1964 if (btv->tuner_type == TUNER_ABSENT)
1965 return -EINVAL;
1967 if (0 != t->index)
1968 return -EINVAL;
1970 mutex_lock(&btv->lock);
1971 bttv_call_all(btv, tuner, s_tuner, t);
1973 if (btv->audio_mode_gpio)
1974 btv->audio_mode_gpio(btv, t, 1);
1976 mutex_unlock(&btv->lock);
1978 return 0;
1981 static int bttv_g_frequency(struct file *file, void *priv,
1982 struct v4l2_frequency *f)
1984 struct bttv_fh *fh = priv;
1985 struct bttv *btv = fh->btv;
1986 int err;
1988 err = v4l2_prio_check(&btv->prio, &fh->prio);
1989 if (0 != err)
1990 return err;
1992 f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1993 f->frequency = btv->freq;
1995 return 0;
1998 static int bttv_s_frequency(struct file *file, void *priv,
1999 struct v4l2_frequency *f)
2001 struct bttv_fh *fh = priv;
2002 struct bttv *btv = fh->btv;
2003 int err;
2005 err = v4l2_prio_check(&btv->prio, &fh->prio);
2006 if (0 != err)
2007 return err;
2009 if (unlikely(f->tuner != 0))
2010 return -EINVAL;
2011 if (unlikely(f->type != (btv->radio_user
2012 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
2013 return -EINVAL;
2014 mutex_lock(&btv->lock);
2015 btv->freq = f->frequency;
2016 bttv_call_all(btv, tuner, s_frequency, f);
2017 if (btv->has_matchbox && btv->radio_user)
2018 tea5757_set_freq(btv, btv->freq);
2019 mutex_unlock(&btv->lock);
2020 return 0;
2023 static int bttv_log_status(struct file *file, void *f)
2025 struct bttv_fh *fh = f;
2026 struct bttv *btv = fh->btv;
2028 printk(KERN_INFO "bttv%d: ======== START STATUS CARD #%d ========\n",
2029 btv->c.nr, btv->c.nr);
2030 bttv_call_all(btv, core, log_status);
2031 printk(KERN_INFO "bttv%d: ======== END STATUS CARD #%d ========\n",
2032 btv->c.nr, btv->c.nr);
2033 return 0;
2036 #ifdef CONFIG_VIDEO_ADV_DEBUG
2037 static int bttv_g_register(struct file *file, void *f,
2038 struct v4l2_dbg_register *reg)
2040 struct bttv_fh *fh = f;
2041 struct bttv *btv = fh->btv;
2043 if (!capable(CAP_SYS_ADMIN))
2044 return -EPERM;
2046 if (!v4l2_chip_match_host(&reg->match))
2047 return -EINVAL;
2049 /* bt848 has a 12-bit register space */
2050 reg->reg &= 0xfff;
2051 reg->val = btread(reg->reg);
2052 reg->size = 1;
2054 return 0;
2057 static int bttv_s_register(struct file *file, void *f,
2058 struct v4l2_dbg_register *reg)
2060 struct bttv_fh *fh = f;
2061 struct bttv *btv = fh->btv;
2063 if (!capable(CAP_SYS_ADMIN))
2064 return -EPERM;
2066 if (!v4l2_chip_match_host(&reg->match))
2067 return -EINVAL;
2069 /* bt848 has a 12-bit register space */
2070 reg->reg &= 0xfff;
2071 btwrite(reg->val, reg->reg);
2073 return 0;
2075 #endif
2077 /* Given cropping boundaries b and the scaled width and height of a
2078 single field or frame, which must not exceed hardware limits, this
2079 function adjusts the cropping parameters c. */
2080 static void
2081 bttv_crop_adjust (struct bttv_crop * c,
2082 const struct v4l2_rect * b,
2083 __s32 width,
2084 __s32 height,
2085 enum v4l2_field field)
2087 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2088 __s32 max_left;
2089 __s32 max_top;
2091 if (width < c->min_scaled_width) {
2092 /* Max. hor. scale factor 16:1. */
2093 c->rect.width = width * 16;
2094 } else if (width > c->max_scaled_width) {
2095 /* Min. hor. scale factor 1:1. */
2096 c->rect.width = width;
2098 max_left = b->left + b->width - width;
2099 max_left = min(max_left, (__s32) MAX_HDELAY);
2100 if (c->rect.left > max_left)
2101 c->rect.left = max_left;
2104 if (height < c->min_scaled_height) {
2105 /* Max. vert. scale factor 16:1, single fields 8:1. */
2106 c->rect.height = height * 16;
2107 } else if (frame_height > c->max_scaled_height) {
2108 /* Min. vert. scale factor 1:1.
2109 Top and height count field lines times two. */
2110 c->rect.height = (frame_height + 1) & ~1;
2112 max_top = b->top + b->height - c->rect.height;
2113 if (c->rect.top > max_top)
2114 c->rect.top = max_top;
2117 bttv_crop_calc_limits(c);
2120 /* Returns an error if scaling to a frame or single field with the given
2121 width and height is not possible with the current cropping parameters
2122 and width aligned according to width_mask. If adjust_size is TRUE the
2123 function may adjust the width and/or height instead, rounding width
2124 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2125 also adjust the current cropping parameters to get closer to the
2126 desired image size. */
2127 static int
2128 limit_scaled_size (struct bttv_fh * fh,
2129 __s32 * width,
2130 __s32 * height,
2131 enum v4l2_field field,
2132 unsigned int width_mask,
2133 unsigned int width_bias,
2134 int adjust_size,
2135 int adjust_crop)
2137 struct bttv *btv = fh->btv;
2138 const struct v4l2_rect *b;
2139 struct bttv_crop *c;
2140 __s32 min_width;
2141 __s32 min_height;
2142 __s32 max_width;
2143 __s32 max_height;
2144 int rc;
2146 BUG_ON((int) width_mask >= 0 ||
2147 width_bias >= (unsigned int) -width_mask);
2149 /* Make sure tvnorm, vbi_end and the current cropping parameters
2150 remain consistent until we're done. */
2151 mutex_lock(&btv->lock);
2153 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2155 /* Do crop - use current, don't - use default parameters. */
2156 c = &btv->crop[!!fh->do_crop];
2158 if (fh->do_crop
2159 && adjust_size
2160 && adjust_crop
2161 && !locked_btres(btv, VIDEO_RESOURCES)) {
2162 min_width = 48;
2163 min_height = 32;
2165 /* We cannot scale up. When the scaled image is larger
2166 than crop.rect we adjust the crop.rect as required
2167 by the V4L2 spec, hence cropcap.bounds are our limit. */
2168 max_width = min(b->width, (__s32) MAX_HACTIVE);
2169 max_height = b->height;
2171 /* We cannot capture the same line as video and VBI data.
2172 Note btv->vbi_end is really a minimum, see
2173 bttv_vbi_try_fmt(). */
2174 if (btv->vbi_end > b->top) {
2175 max_height -= btv->vbi_end - b->top;
2176 rc = -EBUSY;
2177 if (min_height > max_height)
2178 goto fail;
2180 } else {
2181 rc = -EBUSY;
2182 if (btv->vbi_end > c->rect.top)
2183 goto fail;
2185 min_width = c->min_scaled_width;
2186 min_height = c->min_scaled_height;
2187 max_width = c->max_scaled_width;
2188 max_height = c->max_scaled_height;
2190 adjust_crop = 0;
2193 min_width = (min_width - width_mask - 1) & width_mask;
2194 max_width = max_width & width_mask;
2196 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2197 min_height = min_height;
2198 /* Min. scale factor is 1:1. */
2199 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2201 if (adjust_size) {
2202 *width = clamp(*width, min_width, max_width);
2203 *height = clamp(*height, min_height, max_height);
2205 /* Round after clamping to avoid overflow. */
2206 *width = (*width + width_bias) & width_mask;
2208 if (adjust_crop) {
2209 bttv_crop_adjust(c, b, *width, *height, field);
2211 if (btv->vbi_end > c->rect.top) {
2212 /* Move the crop window out of the way. */
2213 c->rect.top = btv->vbi_end;
2216 } else {
2217 rc = -EINVAL;
2218 if (*width < min_width ||
2219 *height < min_height ||
2220 *width > max_width ||
2221 *height > max_height ||
2222 0 != (*width & ~width_mask))
2223 goto fail;
2226 rc = 0; /* success */
2228 fail:
2229 mutex_unlock(&btv->lock);
2231 return rc;
2234 /* Returns an error if the given overlay window dimensions are not
2235 possible with the current cropping parameters. If adjust_size is
2236 TRUE the function may adjust the window width and/or height
2237 instead, however it always rounds the horizontal position and
2238 width as btcx_align() does. If adjust_crop is TRUE the function
2239 may also adjust the current cropping parameters to get closer
2240 to the desired window size. */
2241 static int
2242 verify_window (struct bttv_fh * fh,
2243 struct v4l2_window * win,
2244 int adjust_size,
2245 int adjust_crop)
2247 enum v4l2_field field;
2248 unsigned int width_mask;
2249 int rc;
2251 if (win->w.width < 48 || win->w.height < 32)
2252 return -EINVAL;
2253 if (win->clipcount > 2048)
2254 return -EINVAL;
2256 field = win->field;
2258 if (V4L2_FIELD_ANY == field) {
2259 __s32 height2;
2261 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2262 field = (win->w.height > height2)
2263 ? V4L2_FIELD_INTERLACED
2264 : V4L2_FIELD_TOP;
2266 switch (field) {
2267 case V4L2_FIELD_TOP:
2268 case V4L2_FIELD_BOTTOM:
2269 case V4L2_FIELD_INTERLACED:
2270 break;
2271 default:
2272 return -EINVAL;
2275 /* 4-byte alignment. */
2276 if (NULL == fh->ovfmt)
2277 return -EINVAL;
2278 width_mask = ~0;
2279 switch (fh->ovfmt->depth) {
2280 case 8:
2281 case 24:
2282 width_mask = ~3;
2283 break;
2284 case 16:
2285 width_mask = ~1;
2286 break;
2287 case 32:
2288 break;
2289 default:
2290 BUG();
2293 win->w.width -= win->w.left & ~width_mask;
2294 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2296 rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2297 field, width_mask,
2298 /* width_bias: round down */ 0,
2299 adjust_size, adjust_crop);
2300 if (0 != rc)
2301 return rc;
2303 win->field = field;
2304 return 0;
2307 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2308 struct v4l2_window *win, int fixup)
2310 struct v4l2_clip *clips = NULL;
2311 int n,size,retval = 0;
2313 if (NULL == fh->ovfmt)
2314 return -EINVAL;
2315 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2316 return -EINVAL;
2317 retval = verify_window(fh, win,
2318 /* adjust_size */ fixup,
2319 /* adjust_crop */ fixup);
2320 if (0 != retval)
2321 return retval;
2323 /* copy clips -- luckily v4l1 + v4l2 are binary
2324 compatible here ...*/
2325 n = win->clipcount;
2326 size = sizeof(*clips)*(n+4);
2327 clips = kmalloc(size,GFP_KERNEL);
2328 if (NULL == clips)
2329 return -ENOMEM;
2330 if (n > 0) {
2331 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2332 kfree(clips);
2333 return -EFAULT;
2336 /* clip against screen */
2337 if (NULL != btv->fbuf.base)
2338 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2339 &win->w, clips, n);
2340 btcx_sort_clips(clips,n);
2342 /* 4-byte alignments */
2343 switch (fh->ovfmt->depth) {
2344 case 8:
2345 case 24:
2346 btcx_align(&win->w, clips, n, 3);
2347 break;
2348 case 16:
2349 btcx_align(&win->w, clips, n, 1);
2350 break;
2351 case 32:
2352 /* no alignment fixups needed */
2353 break;
2354 default:
2355 BUG();
2358 mutex_lock(&fh->cap.vb_lock);
2359 kfree(fh->ov.clips);
2360 fh->ov.clips = clips;
2361 fh->ov.nclips = n;
2363 fh->ov.w = win->w;
2364 fh->ov.field = win->field;
2365 fh->ov.setup_ok = 1;
2366 btv->init.ov.w.width = win->w.width;
2367 btv->init.ov.w.height = win->w.height;
2368 btv->init.ov.field = win->field;
2370 /* update overlay if needed */
2371 retval = 0;
2372 if (check_btres(fh, RESOURCE_OVERLAY)) {
2373 struct bttv_buffer *new;
2375 new = videobuf_sg_alloc(sizeof(*new));
2376 new->crop = btv->crop[!!fh->do_crop].rect;
2377 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2378 retval = bttv_switch_overlay(btv,fh,new);
2380 mutex_unlock(&fh->cap.vb_lock);
2381 return retval;
2384 /* ----------------------------------------------------------------------- */
2386 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2388 struct videobuf_queue* q = NULL;
2390 switch (fh->type) {
2391 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2392 q = &fh->cap;
2393 break;
2394 case V4L2_BUF_TYPE_VBI_CAPTURE:
2395 q = &fh->vbi;
2396 break;
2397 default:
2398 BUG();
2400 return q;
2403 static int bttv_resource(struct bttv_fh *fh)
2405 int res = 0;
2407 switch (fh->type) {
2408 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2409 res = RESOURCE_VIDEO_STREAM;
2410 break;
2411 case V4L2_BUF_TYPE_VBI_CAPTURE:
2412 res = RESOURCE_VBI;
2413 break;
2414 default:
2415 BUG();
2417 return res;
2420 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2422 struct videobuf_queue *q = bttv_queue(fh);
2423 int res = bttv_resource(fh);
2425 if (check_btres(fh,res))
2426 return -EBUSY;
2427 if (videobuf_queue_is_busy(q))
2428 return -EBUSY;
2429 fh->type = type;
2430 return 0;
2433 static void
2434 pix_format_set_size (struct v4l2_pix_format * f,
2435 const struct bttv_format * fmt,
2436 unsigned int width,
2437 unsigned int height)
2439 f->width = width;
2440 f->height = height;
2442 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2443 f->bytesperline = width; /* Y plane */
2444 f->sizeimage = (width * height * fmt->depth) >> 3;
2445 } else {
2446 f->bytesperline = (width * fmt->depth) >> 3;
2447 f->sizeimage = height * f->bytesperline;
2451 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2452 struct v4l2_format *f)
2454 struct bttv_fh *fh = priv;
2456 pix_format_set_size(&f->fmt.pix, fh->fmt,
2457 fh->width, fh->height);
2458 f->fmt.pix.field = fh->cap.field;
2459 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2461 return 0;
2464 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2465 struct v4l2_format *f)
2467 struct bttv_fh *fh = priv;
2469 f->fmt.win.w = fh->ov.w;
2470 f->fmt.win.field = fh->ov.field;
2472 return 0;
2475 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2476 struct v4l2_format *f)
2478 const struct bttv_format *fmt;
2479 struct bttv_fh *fh = priv;
2480 struct bttv *btv = fh->btv;
2481 enum v4l2_field field;
2482 __s32 width, height;
2483 int rc;
2485 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2486 if (NULL == fmt)
2487 return -EINVAL;
2489 field = f->fmt.pix.field;
2491 if (V4L2_FIELD_ANY == field) {
2492 __s32 height2;
2494 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2495 field = (f->fmt.pix.height > height2)
2496 ? V4L2_FIELD_INTERLACED
2497 : V4L2_FIELD_BOTTOM;
2500 if (V4L2_FIELD_SEQ_BT == field)
2501 field = V4L2_FIELD_SEQ_TB;
2503 switch (field) {
2504 case V4L2_FIELD_TOP:
2505 case V4L2_FIELD_BOTTOM:
2506 case V4L2_FIELD_ALTERNATE:
2507 case V4L2_FIELD_INTERLACED:
2508 break;
2509 case V4L2_FIELD_SEQ_TB:
2510 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2511 return -EINVAL;
2512 break;
2513 default:
2514 return -EINVAL;
2517 width = f->fmt.pix.width;
2518 height = f->fmt.pix.height;
2520 rc = limit_scaled_size(fh, &width, &height, field,
2521 /* width_mask: 4 pixels */ ~3,
2522 /* width_bias: nearest */ 2,
2523 /* adjust_size */ 1,
2524 /* adjust_crop */ 0);
2525 if (0 != rc)
2526 return rc;
2528 /* update data for the application */
2529 f->fmt.pix.field = field;
2530 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2532 return 0;
2535 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2536 struct v4l2_format *f)
2538 struct bttv_fh *fh = priv;
2540 return verify_window(fh, &f->fmt.win,
2541 /* adjust_size */ 1,
2542 /* adjust_crop */ 0);
2545 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2546 struct v4l2_format *f)
2548 int retval;
2549 const struct bttv_format *fmt;
2550 struct bttv_fh *fh = priv;
2551 struct bttv *btv = fh->btv;
2552 __s32 width, height;
2553 enum v4l2_field field;
2555 retval = bttv_switch_type(fh, f->type);
2556 if (0 != retval)
2557 return retval;
2559 retval = bttv_try_fmt_vid_cap(file, priv, f);
2560 if (0 != retval)
2561 return retval;
2563 width = f->fmt.pix.width;
2564 height = f->fmt.pix.height;
2565 field = f->fmt.pix.field;
2567 retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2568 /* width_mask: 4 pixels */ ~3,
2569 /* width_bias: nearest */ 2,
2570 /* adjust_size */ 1,
2571 /* adjust_crop */ 1);
2572 if (0 != retval)
2573 return retval;
2575 f->fmt.pix.field = field;
2577 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2579 /* update our state informations */
2580 mutex_lock(&fh->cap.vb_lock);
2581 fh->fmt = fmt;
2582 fh->cap.field = f->fmt.pix.field;
2583 fh->cap.last = V4L2_FIELD_NONE;
2584 fh->width = f->fmt.pix.width;
2585 fh->height = f->fmt.pix.height;
2586 btv->init.fmt = fmt;
2587 btv->init.width = f->fmt.pix.width;
2588 btv->init.height = f->fmt.pix.height;
2589 mutex_unlock(&fh->cap.vb_lock);
2591 return 0;
2594 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2595 struct v4l2_format *f)
2597 struct bttv_fh *fh = priv;
2598 struct bttv *btv = fh->btv;
2600 if (no_overlay > 0) {
2601 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2602 return -EINVAL;
2605 return setup_window(fh, btv, &f->fmt.win, 1);
2608 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2609 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2611 int retval;
2612 unsigned int i;
2613 struct bttv_fh *fh = priv;
2615 mutex_lock(&fh->cap.vb_lock);
2616 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2617 V4L2_MEMORY_MMAP);
2618 if (retval < 0) {
2619 mutex_unlock(&fh->cap.vb_lock);
2620 return retval;
2623 gbuffers = retval;
2624 memset(mbuf, 0, sizeof(*mbuf));
2625 mbuf->frames = gbuffers;
2626 mbuf->size = gbuffers * gbufsize;
2628 for (i = 0; i < gbuffers; i++)
2629 mbuf->offsets[i] = i * gbufsize;
2631 mutex_unlock(&fh->cap.vb_lock);
2632 return 0;
2634 #endif
2636 static int bttv_querycap(struct file *file, void *priv,
2637 struct v4l2_capability *cap)
2639 struct bttv_fh *fh = priv;
2640 struct bttv *btv = fh->btv;
2642 if (0 == v4l2)
2643 return -EINVAL;
2645 strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2646 strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2647 snprintf(cap->bus_info, sizeof(cap->bus_info),
2648 "PCI:%s", pci_name(btv->c.pci));
2649 cap->version = BTTV_VERSION_CODE;
2650 cap->capabilities =
2651 V4L2_CAP_VIDEO_CAPTURE |
2652 V4L2_CAP_VBI_CAPTURE |
2653 V4L2_CAP_READWRITE |
2654 V4L2_CAP_STREAMING;
2655 if (no_overlay <= 0)
2656 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2658 if (btv->tuner_type != TUNER_ABSENT)
2659 cap->capabilities |= V4L2_CAP_TUNER;
2660 return 0;
2663 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2665 int index = -1, i;
2667 for (i = 0; i < FORMATS; i++) {
2668 if (formats[i].fourcc != -1)
2669 index++;
2670 if ((unsigned int)index == f->index)
2671 break;
2673 if (FORMATS == i)
2674 return -EINVAL;
2676 f->pixelformat = formats[i].fourcc;
2677 strlcpy(f->description, formats[i].name, sizeof(f->description));
2679 return i;
2682 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
2683 struct v4l2_fmtdesc *f)
2685 int rc = bttv_enum_fmt_cap_ovr(f);
2687 if (rc < 0)
2688 return rc;
2690 return 0;
2693 static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv,
2694 struct v4l2_fmtdesc *f)
2696 int rc;
2698 if (no_overlay > 0) {
2699 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2700 return -EINVAL;
2703 rc = bttv_enum_fmt_cap_ovr(f);
2705 if (rc < 0)
2706 return rc;
2708 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2709 return -EINVAL;
2711 return 0;
2714 static int bttv_g_fbuf(struct file *file, void *f,
2715 struct v4l2_framebuffer *fb)
2717 struct bttv_fh *fh = f;
2718 struct bttv *btv = fh->btv;
2720 *fb = btv->fbuf;
2721 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2722 if (fh->ovfmt)
2723 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2724 return 0;
2727 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2729 struct bttv_fh *fh = f;
2730 struct bttv *btv = fh->btv;
2731 struct bttv_buffer *new;
2732 int retval;
2734 if (on) {
2735 /* verify args */
2736 if (NULL == btv->fbuf.base)
2737 return -EINVAL;
2738 if (!fh->ov.setup_ok) {
2739 dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2740 return -EINVAL;
2744 if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2745 return -EBUSY;
2747 mutex_lock(&fh->cap.vb_lock);
2748 if (on) {
2749 fh->ov.tvnorm = btv->tvnorm;
2750 new = videobuf_sg_alloc(sizeof(*new));
2751 new->crop = btv->crop[!!fh->do_crop].rect;
2752 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2753 } else {
2754 new = NULL;
2757 /* switch over */
2758 retval = bttv_switch_overlay(btv, fh, new);
2759 mutex_unlock(&fh->cap.vb_lock);
2760 return retval;
2763 static int bttv_s_fbuf(struct file *file, void *f,
2764 struct v4l2_framebuffer *fb)
2766 struct bttv_fh *fh = f;
2767 struct bttv *btv = fh->btv;
2768 const struct bttv_format *fmt;
2769 int retval;
2771 if (!capable(CAP_SYS_ADMIN) &&
2772 !capable(CAP_SYS_RAWIO))
2773 return -EPERM;
2775 /* check args */
2776 fmt = format_by_fourcc(fb->fmt.pixelformat);
2777 if (NULL == fmt)
2778 return -EINVAL;
2779 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2780 return -EINVAL;
2782 retval = -EINVAL;
2783 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2784 __s32 width = fb->fmt.width;
2785 __s32 height = fb->fmt.height;
2787 retval = limit_scaled_size(fh, &width, &height,
2788 V4L2_FIELD_INTERLACED,
2789 /* width_mask */ ~3,
2790 /* width_bias */ 2,
2791 /* adjust_size */ 0,
2792 /* adjust_crop */ 0);
2793 if (0 != retval)
2794 return retval;
2797 /* ok, accept it */
2798 mutex_lock(&fh->cap.vb_lock);
2799 btv->fbuf.base = fb->base;
2800 btv->fbuf.fmt.width = fb->fmt.width;
2801 btv->fbuf.fmt.height = fb->fmt.height;
2802 if (0 != fb->fmt.bytesperline)
2803 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2804 else
2805 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2807 retval = 0;
2808 fh->ovfmt = fmt;
2809 btv->init.ovfmt = fmt;
2810 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2811 fh->ov.w.left = 0;
2812 fh->ov.w.top = 0;
2813 fh->ov.w.width = fb->fmt.width;
2814 fh->ov.w.height = fb->fmt.height;
2815 btv->init.ov.w.width = fb->fmt.width;
2816 btv->init.ov.w.height = fb->fmt.height;
2817 kfree(fh->ov.clips);
2818 fh->ov.clips = NULL;
2819 fh->ov.nclips = 0;
2821 if (check_btres(fh, RESOURCE_OVERLAY)) {
2822 struct bttv_buffer *new;
2824 new = videobuf_sg_alloc(sizeof(*new));
2825 new->crop = btv->crop[!!fh->do_crop].rect;
2826 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2827 retval = bttv_switch_overlay(btv, fh, new);
2830 mutex_unlock(&fh->cap.vb_lock);
2831 return retval;
2834 static int bttv_reqbufs(struct file *file, void *priv,
2835 struct v4l2_requestbuffers *p)
2837 struct bttv_fh *fh = priv;
2838 return videobuf_reqbufs(bttv_queue(fh), p);
2841 static int bttv_querybuf(struct file *file, void *priv,
2842 struct v4l2_buffer *b)
2844 struct bttv_fh *fh = priv;
2845 return videobuf_querybuf(bttv_queue(fh), b);
2848 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2850 struct bttv_fh *fh = priv;
2851 struct bttv *btv = fh->btv;
2852 int res = bttv_resource(fh);
2854 if (!check_alloc_btres(btv, fh, res))
2855 return -EBUSY;
2857 return videobuf_qbuf(bttv_queue(fh), b);
2860 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2862 struct bttv_fh *fh = priv;
2863 return videobuf_dqbuf(bttv_queue(fh), b,
2864 file->f_flags & O_NONBLOCK);
2867 static int bttv_streamon(struct file *file, void *priv,
2868 enum v4l2_buf_type type)
2870 struct bttv_fh *fh = priv;
2871 struct bttv *btv = fh->btv;
2872 int res = bttv_resource(fh);
2874 if (!check_alloc_btres(btv, fh, res))
2875 return -EBUSY;
2876 return videobuf_streamon(bttv_queue(fh));
2880 static int bttv_streamoff(struct file *file, void *priv,
2881 enum v4l2_buf_type type)
2883 struct bttv_fh *fh = priv;
2884 struct bttv *btv = fh->btv;
2885 int retval;
2886 int res = bttv_resource(fh);
2889 retval = videobuf_streamoff(bttv_queue(fh));
2890 if (retval < 0)
2891 return retval;
2892 free_btres(btv, fh, res);
2893 return 0;
2896 static int bttv_queryctrl(struct file *file, void *priv,
2897 struct v4l2_queryctrl *c)
2899 struct bttv_fh *fh = priv;
2900 struct bttv *btv = fh->btv;
2901 const struct v4l2_queryctrl *ctrl;
2903 if ((c->id < V4L2_CID_BASE ||
2904 c->id >= V4L2_CID_LASTP1) &&
2905 (c->id < V4L2_CID_PRIVATE_BASE ||
2906 c->id >= V4L2_CID_PRIVATE_LASTP1))
2907 return -EINVAL;
2909 if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2910 *c = no_ctl;
2911 else {
2912 ctrl = ctrl_by_id(c->id);
2914 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2917 return 0;
2920 static int bttv_g_parm(struct file *file, void *f,
2921 struct v4l2_streamparm *parm)
2923 struct bttv_fh *fh = f;
2924 struct bttv *btv = fh->btv;
2926 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2927 &parm->parm.capture.timeperframe);
2928 return 0;
2931 static int bttv_g_tuner(struct file *file, void *priv,
2932 struct v4l2_tuner *t)
2934 struct bttv_fh *fh = priv;
2935 struct bttv *btv = fh->btv;
2937 if (btv->tuner_type == TUNER_ABSENT)
2938 return -EINVAL;
2939 if (0 != t->index)
2940 return -EINVAL;
2942 mutex_lock(&btv->lock);
2943 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2944 bttv_call_all(btv, tuner, g_tuner, t);
2945 strcpy(t->name, "Television");
2946 t->capability = V4L2_TUNER_CAP_NORM;
2947 t->type = V4L2_TUNER_ANALOG_TV;
2948 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2949 t->signal = 0xffff;
2951 if (btv->audio_mode_gpio)
2952 btv->audio_mode_gpio(btv, t, 0);
2954 mutex_unlock(&btv->lock);
2955 return 0;
2958 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2960 struct bttv_fh *fh = f;
2961 struct bttv *btv = fh->btv;
2963 *p = v4l2_prio_max(&btv->prio);
2965 return 0;
2968 static int bttv_s_priority(struct file *file, void *f,
2969 enum v4l2_priority prio)
2971 struct bttv_fh *fh = f;
2972 struct bttv *btv = fh->btv;
2974 return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2977 static int bttv_cropcap(struct file *file, void *priv,
2978 struct v4l2_cropcap *cap)
2980 struct bttv_fh *fh = priv;
2981 struct bttv *btv = fh->btv;
2983 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2984 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2985 return -EINVAL;
2987 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
2989 return 0;
2992 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
2994 struct bttv_fh *fh = f;
2995 struct bttv *btv = fh->btv;
2997 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2998 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2999 return -EINVAL;
3001 /* No fh->do_crop = 1; because btv->crop[1] may be
3002 inconsistent with fh->width or fh->height and apps
3003 do not expect a change here. */
3005 crop->c = btv->crop[!!fh->do_crop].rect;
3007 return 0;
3010 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3012 struct bttv_fh *fh = f;
3013 struct bttv *btv = fh->btv;
3014 const struct v4l2_rect *b;
3015 int retval;
3016 struct bttv_crop c;
3017 __s32 b_left;
3018 __s32 b_top;
3019 __s32 b_right;
3020 __s32 b_bottom;
3022 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3023 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3024 return -EINVAL;
3026 retval = v4l2_prio_check(&btv->prio, &fh->prio);
3027 if (0 != retval)
3028 return retval;
3030 /* Make sure tvnorm, vbi_end and the current cropping
3031 parameters remain consistent until we're done. Note
3032 read() may change vbi_end in check_alloc_btres(). */
3033 mutex_lock(&btv->lock);
3035 retval = -EBUSY;
3037 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3038 mutex_unlock(&btv->lock);
3039 return retval;
3042 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3044 b_left = b->left;
3045 b_right = b_left + b->width;
3046 b_bottom = b->top + b->height;
3048 b_top = max(b->top, btv->vbi_end);
3049 if (b_top + 32 >= b_bottom) {
3050 mutex_unlock(&btv->lock);
3051 return retval;
3054 /* Min. scaled size 48 x 32. */
3055 c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3056 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3058 c.rect.width = clamp(crop->c.width,
3059 48, b_right - c.rect.left);
3061 c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3062 /* Top and height must be a multiple of two. */
3063 c.rect.top = (c.rect.top + 1) & ~1;
3065 c.rect.height = clamp(crop->c.height,
3066 32, b_bottom - c.rect.top);
3067 c.rect.height = (c.rect.height + 1) & ~1;
3069 bttv_crop_calc_limits(&c);
3071 btv->crop[1] = c;
3073 mutex_unlock(&btv->lock);
3075 fh->do_crop = 1;
3077 mutex_lock(&fh->cap.vb_lock);
3079 if (fh->width < c.min_scaled_width) {
3080 fh->width = c.min_scaled_width;
3081 btv->init.width = c.min_scaled_width;
3082 } else if (fh->width > c.max_scaled_width) {
3083 fh->width = c.max_scaled_width;
3084 btv->init.width = c.max_scaled_width;
3087 if (fh->height < c.min_scaled_height) {
3088 fh->height = c.min_scaled_height;
3089 btv->init.height = c.min_scaled_height;
3090 } else if (fh->height > c.max_scaled_height) {
3091 fh->height = c.max_scaled_height;
3092 btv->init.height = c.max_scaled_height;
3095 mutex_unlock(&fh->cap.vb_lock);
3097 return 0;
3100 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3102 if (unlikely(a->index))
3103 return -EINVAL;
3105 strcpy(a->name, "audio");
3106 return 0;
3109 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3111 if (unlikely(a->index))
3112 return -EINVAL;
3114 return 0;
3117 static ssize_t bttv_read(struct file *file, char __user *data,
3118 size_t count, loff_t *ppos)
3120 struct bttv_fh *fh = file->private_data;
3121 int retval = 0;
3123 if (fh->btv->errors)
3124 bttv_reinit_bt848(fh->btv);
3125 dprintk("bttv%d: read count=%d type=%s\n",
3126 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3128 switch (fh->type) {
3129 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3130 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3131 /* VIDEO_READ in use by another fh,
3132 or VIDEO_STREAM by any fh. */
3133 return -EBUSY;
3135 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3136 file->f_flags & O_NONBLOCK);
3137 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3138 break;
3139 case V4L2_BUF_TYPE_VBI_CAPTURE:
3140 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3141 return -EBUSY;
3142 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3143 file->f_flags & O_NONBLOCK);
3144 break;
3145 default:
3146 BUG();
3148 return retval;
3151 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3153 struct bttv_fh *fh = file->private_data;
3154 struct bttv_buffer *buf;
3155 enum v4l2_field field;
3156 unsigned int rc = POLLERR;
3158 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3159 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3160 return POLLERR;
3161 return videobuf_poll_stream(file, &fh->vbi, wait);
3164 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3165 mutex_lock(&fh->cap.vb_lock);
3166 /* streaming capture */
3167 if (list_empty(&fh->cap.stream))
3168 goto err;
3169 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3170 } else {
3171 /* read() capture */
3172 mutex_lock(&fh->cap.vb_lock);
3173 if (NULL == fh->cap.read_buf) {
3174 /* need to capture a new frame */
3175 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3176 goto err;
3177 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3178 if (NULL == fh->cap.read_buf)
3179 goto err;
3180 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3181 field = videobuf_next_field(&fh->cap);
3182 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3183 kfree (fh->cap.read_buf);
3184 fh->cap.read_buf = NULL;
3185 goto err;
3187 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3188 fh->cap.read_off = 0;
3190 mutex_unlock(&fh->cap.vb_lock);
3191 buf = (struct bttv_buffer*)fh->cap.read_buf;
3194 poll_wait(file, &buf->vb.done, wait);
3195 if (buf->vb.state == VIDEOBUF_DONE ||
3196 buf->vb.state == VIDEOBUF_ERROR)
3197 rc = POLLIN|POLLRDNORM;
3198 else
3199 rc = 0;
3200 err:
3201 mutex_unlock(&fh->cap.vb_lock);
3202 return rc;
3205 static int bttv_open(struct file *file)
3207 int minor = video_devdata(file)->minor;
3208 struct bttv *btv = video_drvdata(file);
3209 struct bttv_fh *fh;
3210 enum v4l2_buf_type type = 0;
3212 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3214 lock_kernel();
3215 if (btv->video_dev->minor == minor) {
3216 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3217 } else if (btv->vbi_dev->minor == minor) {
3218 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3219 } else {
3220 WARN_ON(1);
3221 unlock_kernel();
3222 return -ENODEV;
3225 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3226 btv->c.nr,v4l2_type_names[type]);
3228 /* allocate per filehandle data */
3229 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3230 if (NULL == fh) {
3231 unlock_kernel();
3232 return -ENOMEM;
3234 file->private_data = fh;
3235 *fh = btv->init;
3236 fh->type = type;
3237 fh->ov.setup_ok = 0;
3238 v4l2_prio_open(&btv->prio,&fh->prio);
3240 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3241 &btv->c.pci->dev, &btv->s_lock,
3242 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3243 V4L2_FIELD_INTERLACED,
3244 sizeof(struct bttv_buffer),
3245 fh);
3246 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3247 &btv->c.pci->dev, &btv->s_lock,
3248 V4L2_BUF_TYPE_VBI_CAPTURE,
3249 V4L2_FIELD_SEQ_TB,
3250 sizeof(struct bttv_buffer),
3251 fh);
3252 set_tvnorm(btv,btv->tvnorm);
3253 set_input(btv, btv->input, btv->tvnorm);
3255 btv->users++;
3257 /* The V4L2 spec requires one global set of cropping parameters
3258 which only change on request. These are stored in btv->crop[1].
3259 However for compatibility with V4L apps and cropping unaware
3260 V4L2 apps we now reset the cropping parameters as seen through
3261 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3262 will use btv->crop[0], the default cropping parameters for the
3263 current video standard, and VIDIOC_S_FMT will not implicitely
3264 change the cropping parameters until VIDIOC_S_CROP has been
3265 called. */
3266 fh->do_crop = !reset_crop; /* module parameter */
3268 /* Likewise there should be one global set of VBI capture
3269 parameters, but for compatibility with V4L apps and earlier
3270 driver versions each fh has its own parameters. */
3271 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3273 bttv_field_count(btv);
3274 unlock_kernel();
3275 return 0;
3278 static int bttv_release(struct file *file)
3280 struct bttv_fh *fh = file->private_data;
3281 struct bttv *btv = fh->btv;
3283 /* turn off overlay */
3284 if (check_btres(fh, RESOURCE_OVERLAY))
3285 bttv_switch_overlay(btv,fh,NULL);
3287 /* stop video capture */
3288 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3289 videobuf_streamoff(&fh->cap);
3290 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3292 if (fh->cap.read_buf) {
3293 buffer_release(&fh->cap,fh->cap.read_buf);
3294 kfree(fh->cap.read_buf);
3296 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3297 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3300 /* stop vbi capture */
3301 if (check_btres(fh, RESOURCE_VBI)) {
3302 videobuf_stop(&fh->vbi);
3303 free_btres(btv,fh,RESOURCE_VBI);
3306 /* free stuff */
3307 videobuf_mmap_free(&fh->cap);
3308 videobuf_mmap_free(&fh->vbi);
3309 v4l2_prio_close(&btv->prio,&fh->prio);
3310 file->private_data = NULL;
3311 kfree(fh);
3313 btv->users--;
3314 bttv_field_count(btv);
3316 if (!btv->users)
3317 audio_mute(btv, 1);
3319 return 0;
3322 static int
3323 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3325 struct bttv_fh *fh = file->private_data;
3327 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3328 fh->btv->c.nr, v4l2_type_names[fh->type],
3329 vma->vm_start, vma->vm_end - vma->vm_start);
3330 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3333 static const struct v4l2_file_operations bttv_fops =
3335 .owner = THIS_MODULE,
3336 .open = bttv_open,
3337 .release = bttv_release,
3338 .ioctl = video_ioctl2,
3339 .read = bttv_read,
3340 .mmap = bttv_mmap,
3341 .poll = bttv_poll,
3344 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3345 .vidioc_querycap = bttv_querycap,
3346 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
3347 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
3348 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
3349 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
3350 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay,
3351 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay,
3352 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay,
3353 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay,
3354 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
3355 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
3356 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
3357 .vidioc_g_audio = bttv_g_audio,
3358 .vidioc_s_audio = bttv_s_audio,
3359 .vidioc_cropcap = bttv_cropcap,
3360 .vidioc_reqbufs = bttv_reqbufs,
3361 .vidioc_querybuf = bttv_querybuf,
3362 .vidioc_qbuf = bttv_qbuf,
3363 .vidioc_dqbuf = bttv_dqbuf,
3364 .vidioc_s_std = bttv_s_std,
3365 .vidioc_enum_input = bttv_enum_input,
3366 .vidioc_g_input = bttv_g_input,
3367 .vidioc_s_input = bttv_s_input,
3368 .vidioc_queryctrl = bttv_queryctrl,
3369 .vidioc_g_ctrl = bttv_g_ctrl,
3370 .vidioc_s_ctrl = bttv_s_ctrl,
3371 .vidioc_streamon = bttv_streamon,
3372 .vidioc_streamoff = bttv_streamoff,
3373 .vidioc_g_tuner = bttv_g_tuner,
3374 .vidioc_s_tuner = bttv_s_tuner,
3375 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3376 .vidiocgmbuf = vidiocgmbuf,
3377 #endif
3378 .vidioc_g_crop = bttv_g_crop,
3379 .vidioc_s_crop = bttv_s_crop,
3380 .vidioc_g_fbuf = bttv_g_fbuf,
3381 .vidioc_s_fbuf = bttv_s_fbuf,
3382 .vidioc_overlay = bttv_overlay,
3383 .vidioc_g_priority = bttv_g_priority,
3384 .vidioc_s_priority = bttv_s_priority,
3385 .vidioc_g_parm = bttv_g_parm,
3386 .vidioc_g_frequency = bttv_g_frequency,
3387 .vidioc_s_frequency = bttv_s_frequency,
3388 .vidioc_log_status = bttv_log_status,
3389 .vidioc_querystd = bttv_querystd,
3390 #ifdef CONFIG_VIDEO_ADV_DEBUG
3391 .vidioc_g_register = bttv_g_register,
3392 .vidioc_s_register = bttv_s_register,
3393 #endif
3396 static struct video_device bttv_video_template = {
3397 .fops = &bttv_fops,
3398 .minor = -1,
3399 .ioctl_ops = &bttv_ioctl_ops,
3400 .tvnorms = BTTV_NORMS,
3401 .current_norm = V4L2_STD_PAL,
3404 /* ----------------------------------------------------------------------- */
3405 /* radio interface */
3407 static int radio_open(struct file *file)
3409 int minor = video_devdata(file)->minor;
3410 struct bttv *btv = video_drvdata(file);
3411 struct bttv_fh *fh;
3413 dprintk("bttv: open minor=%d\n",minor);
3415 lock_kernel();
3416 WARN_ON(btv->radio_dev && btv->radio_dev->minor != minor);
3417 if (!btv->radio_dev || btv->radio_dev->minor != minor) {
3418 unlock_kernel();
3419 return -ENODEV;
3422 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3424 /* allocate per filehandle data */
3425 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3426 if (NULL == fh) {
3427 unlock_kernel();
3428 return -ENOMEM;
3430 file->private_data = fh;
3431 *fh = btv->init;
3432 v4l2_prio_open(&btv->prio, &fh->prio);
3434 mutex_lock(&btv->lock);
3436 btv->radio_user++;
3438 bttv_call_all(btv, tuner, s_radio);
3439 audio_input(btv,TVAUDIO_INPUT_RADIO);
3441 mutex_unlock(&btv->lock);
3442 unlock_kernel();
3443 return 0;
3446 static int radio_release(struct file *file)
3448 struct bttv_fh *fh = file->private_data;
3449 struct bttv *btv = fh->btv;
3450 struct rds_command cmd;
3452 v4l2_prio_close(&btv->prio,&fh->prio);
3453 file->private_data = NULL;
3454 kfree(fh);
3456 btv->radio_user--;
3458 bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
3460 return 0;
3463 static int radio_querycap(struct file *file, void *priv,
3464 struct v4l2_capability *cap)
3466 struct bttv_fh *fh = priv;
3467 struct bttv *btv = fh->btv;
3469 strcpy(cap->driver, "bttv");
3470 strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3471 sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3472 cap->version = BTTV_VERSION_CODE;
3473 cap->capabilities = V4L2_CAP_TUNER;
3475 return 0;
3478 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3480 struct bttv_fh *fh = priv;
3481 struct bttv *btv = fh->btv;
3483 if (btv->tuner_type == TUNER_ABSENT)
3484 return -EINVAL;
3485 if (0 != t->index)
3486 return -EINVAL;
3487 mutex_lock(&btv->lock);
3488 strcpy(t->name, "Radio");
3489 t->type = V4L2_TUNER_RADIO;
3491 bttv_call_all(btv, tuner, g_tuner, t);
3493 if (btv->audio_mode_gpio)
3494 btv->audio_mode_gpio(btv, t, 0);
3496 mutex_unlock(&btv->lock);
3498 return 0;
3501 static int radio_enum_input(struct file *file, void *priv,
3502 struct v4l2_input *i)
3504 if (i->index != 0)
3505 return -EINVAL;
3507 strcpy(i->name, "Radio");
3508 i->type = V4L2_INPUT_TYPE_TUNER;
3510 return 0;
3513 static int radio_g_audio(struct file *file, void *priv,
3514 struct v4l2_audio *a)
3516 if (unlikely(a->index))
3517 return -EINVAL;
3519 strcpy(a->name, "Radio");
3521 return 0;
3524 static int radio_s_tuner(struct file *file, void *priv,
3525 struct v4l2_tuner *t)
3527 struct bttv_fh *fh = priv;
3528 struct bttv *btv = fh->btv;
3530 if (0 != t->index)
3531 return -EINVAL;
3533 bttv_call_all(btv, tuner, g_tuner, t);
3534 return 0;
3537 static int radio_s_audio(struct file *file, void *priv,
3538 struct v4l2_audio *a)
3540 if (unlikely(a->index))
3541 return -EINVAL;
3543 return 0;
3546 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3548 if (unlikely(i))
3549 return -EINVAL;
3551 return 0;
3554 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3556 return 0;
3559 static int radio_queryctrl(struct file *file, void *priv,
3560 struct v4l2_queryctrl *c)
3562 const struct v4l2_queryctrl *ctrl;
3564 if (c->id < V4L2_CID_BASE ||
3565 c->id >= V4L2_CID_LASTP1)
3566 return -EINVAL;
3568 if (c->id == V4L2_CID_AUDIO_MUTE) {
3569 ctrl = ctrl_by_id(c->id);
3570 *c = *ctrl;
3571 } else
3572 *c = no_ctl;
3574 return 0;
3577 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3579 *i = 0;
3580 return 0;
3583 static ssize_t radio_read(struct file *file, char __user *data,
3584 size_t count, loff_t *ppos)
3586 struct bttv_fh *fh = file->private_data;
3587 struct bttv *btv = fh->btv;
3588 struct rds_command cmd;
3589 cmd.block_count = count/3;
3590 cmd.buffer = data;
3591 cmd.instance = file;
3592 cmd.result = -ENODEV;
3594 bttv_call_all(btv, core, ioctl, RDS_CMD_READ, &cmd);
3596 return cmd.result;
3599 static unsigned int radio_poll(struct file *file, poll_table *wait)
3601 struct bttv_fh *fh = file->private_data;
3602 struct bttv *btv = fh->btv;
3603 struct rds_command cmd;
3604 cmd.instance = file;
3605 cmd.event_list = wait;
3606 cmd.result = -ENODEV;
3607 bttv_call_all(btv, core, ioctl, RDS_CMD_POLL, &cmd);
3609 return cmd.result;
3612 static const struct v4l2_file_operations radio_fops =
3614 .owner = THIS_MODULE,
3615 .open = radio_open,
3616 .read = radio_read,
3617 .release = radio_release,
3618 .ioctl = video_ioctl2,
3619 .poll = radio_poll,
3622 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3623 .vidioc_querycap = radio_querycap,
3624 .vidioc_g_tuner = radio_g_tuner,
3625 .vidioc_enum_input = radio_enum_input,
3626 .vidioc_g_audio = radio_g_audio,
3627 .vidioc_s_tuner = radio_s_tuner,
3628 .vidioc_s_audio = radio_s_audio,
3629 .vidioc_s_input = radio_s_input,
3630 .vidioc_s_std = radio_s_std,
3631 .vidioc_queryctrl = radio_queryctrl,
3632 .vidioc_g_input = radio_g_input,
3633 .vidioc_g_ctrl = bttv_g_ctrl,
3634 .vidioc_s_ctrl = bttv_s_ctrl,
3635 .vidioc_g_frequency = bttv_g_frequency,
3636 .vidioc_s_frequency = bttv_s_frequency,
3639 static struct video_device radio_template = {
3640 .fops = &radio_fops,
3641 .minor = -1,
3642 .ioctl_ops = &radio_ioctl_ops,
3645 /* ----------------------------------------------------------------------- */
3646 /* some debug code */
3648 static int bttv_risc_decode(u32 risc)
3650 static char *instr[16] = {
3651 [ BT848_RISC_WRITE >> 28 ] = "write",
3652 [ BT848_RISC_SKIP >> 28 ] = "skip",
3653 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3654 [ BT848_RISC_JUMP >> 28 ] = "jump",
3655 [ BT848_RISC_SYNC >> 28 ] = "sync",
3656 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3657 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3658 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3660 static int incr[16] = {
3661 [ BT848_RISC_WRITE >> 28 ] = 2,
3662 [ BT848_RISC_JUMP >> 28 ] = 2,
3663 [ BT848_RISC_SYNC >> 28 ] = 2,
3664 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3665 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3666 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3668 static char *bits[] = {
3669 "be0", "be1", "be2", "be3/resync",
3670 "set0", "set1", "set2", "set3",
3671 "clr0", "clr1", "clr2", "clr3",
3672 "irq", "res", "eol", "sol",
3674 int i;
3676 printk("0x%08x [ %s", risc,
3677 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3678 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3679 if (risc & (1 << (i + 12)))
3680 printk(" %s",bits[i]);
3681 printk(" count=%d ]\n", risc & 0xfff);
3682 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3685 static void bttv_risc_disasm(struct bttv *btv,
3686 struct btcx_riscmem *risc)
3688 unsigned int i,j,n;
3690 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3691 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3692 for (i = 0; i < (risc->size >> 2); i += n) {
3693 printk("%s: 0x%lx: ", btv->c.v4l2_dev.name,
3694 (unsigned long)(risc->dma + (i<<2)));
3695 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3696 for (j = 1; j < n; j++)
3697 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3698 btv->c.v4l2_dev.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3699 risc->cpu[i+j], j);
3700 if (0 == risc->cpu[i])
3701 break;
3705 static void bttv_print_riscaddr(struct bttv *btv)
3707 printk(" main: %08Lx\n",
3708 (unsigned long long)btv->main.dma);
3709 printk(" vbi : o=%08Lx e=%08Lx\n",
3710 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3711 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3712 printk(" cap : o=%08Lx e=%08Lx\n",
3713 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3714 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3715 printk(" scr : o=%08Lx e=%08Lx\n",
3716 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3717 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3718 bttv_risc_disasm(btv, &btv->main);
3721 /* ----------------------------------------------------------------------- */
3722 /* irq handler */
3724 static char *irq_name[] = {
3725 "FMTCHG", // format change detected (525 vs. 625)
3726 "VSYNC", // vertical sync (new field)
3727 "HSYNC", // horizontal sync
3728 "OFLOW", // chroma/luma AGC overflow
3729 "HLOCK", // horizontal lock changed
3730 "VPRES", // video presence changed
3731 "6", "7",
3732 "I2CDONE", // hw irc operation finished
3733 "GPINT", // gpio port triggered irq
3734 "10",
3735 "RISCI", // risc instruction triggered irq
3736 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3737 "FTRGT", // pixel data fifo overrun
3738 "FDSR", // fifo data stream resyncronisation
3739 "PPERR", // parity error (data transfer)
3740 "RIPERR", // parity error (read risc instructions)
3741 "PABORT", // pci abort
3742 "OCERR", // risc instruction error
3743 "SCERR", // syncronisation error
3746 static void bttv_print_irqbits(u32 print, u32 mark)
3748 unsigned int i;
3750 printk("bits:");
3751 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3752 if (print & (1 << i))
3753 printk(" %s",irq_name[i]);
3754 if (mark & (1 << i))
3755 printk("*");
3759 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3761 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3762 btv->c.nr,
3763 (unsigned long)btv->main.dma,
3764 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3765 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3766 (unsigned long)rc);
3768 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3769 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3770 "Ok, then this is harmless, don't worry ;)\n",
3771 btv->c.nr);
3772 return;
3774 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3775 btv->c.nr);
3776 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3777 btv->c.nr);
3778 dump_stack();
3781 static int
3782 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3784 struct bttv_buffer *item;
3786 memset(set,0,sizeof(*set));
3788 /* capture request ? */
3789 if (!list_empty(&btv->capture)) {
3790 set->frame_irq = 1;
3791 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3792 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3793 set->top = item;
3794 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3795 set->bottom = item;
3797 /* capture request for other field ? */
3798 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3799 (item->vb.queue.next != &btv->capture)) {
3800 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3801 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3802 if (NULL == set->top &&
3803 V4L2_FIELD_TOP == item->vb.field) {
3804 set->top = item;
3806 if (NULL == set->bottom &&
3807 V4L2_FIELD_BOTTOM == item->vb.field) {
3808 set->bottom = item;
3810 if (NULL != set->top && NULL != set->bottom)
3811 set->top_irq = 2;
3816 /* screen overlay ? */
3817 if (NULL != btv->screen) {
3818 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3819 if (NULL == set->top && NULL == set->bottom) {
3820 set->top = btv->screen;
3821 set->bottom = btv->screen;
3823 } else {
3824 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3825 NULL == set->top) {
3826 set->top = btv->screen;
3828 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3829 NULL == set->bottom) {
3830 set->bottom = btv->screen;
3835 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3836 btv->c.nr,set->top, set->bottom,
3837 btv->screen,set->frame_irq,set->top_irq);
3838 return 0;
3841 static void
3842 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3843 struct bttv_buffer_set *curr, unsigned int state)
3845 struct timeval ts;
3847 do_gettimeofday(&ts);
3849 if (wakeup->top == wakeup->bottom) {
3850 if (NULL != wakeup->top && curr->top != wakeup->top) {
3851 if (irq_debug > 1)
3852 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3853 wakeup->top->vb.ts = ts;
3854 wakeup->top->vb.field_count = btv->field_count;
3855 wakeup->top->vb.state = state;
3856 wake_up(&wakeup->top->vb.done);
3858 } else {
3859 if (NULL != wakeup->top && curr->top != wakeup->top) {
3860 if (irq_debug > 1)
3861 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3862 wakeup->top->vb.ts = ts;
3863 wakeup->top->vb.field_count = btv->field_count;
3864 wakeup->top->vb.state = state;
3865 wake_up(&wakeup->top->vb.done);
3867 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3868 if (irq_debug > 1)
3869 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3870 wakeup->bottom->vb.ts = ts;
3871 wakeup->bottom->vb.field_count = btv->field_count;
3872 wakeup->bottom->vb.state = state;
3873 wake_up(&wakeup->bottom->vb.done);
3878 static void
3879 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3880 unsigned int state)
3882 struct timeval ts;
3884 if (NULL == wakeup)
3885 return;
3887 do_gettimeofday(&ts);
3888 wakeup->vb.ts = ts;
3889 wakeup->vb.field_count = btv->field_count;
3890 wakeup->vb.state = state;
3891 wake_up(&wakeup->vb.done);
3894 static void bttv_irq_timeout(unsigned long data)
3896 struct bttv *btv = (struct bttv *)data;
3897 struct bttv_buffer_set old,new;
3898 struct bttv_buffer *ovbi;
3899 struct bttv_buffer *item;
3900 unsigned long flags;
3902 if (bttv_verbose) {
3903 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3904 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3905 btread(BT848_RISC_COUNT));
3906 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3907 printk("\n");
3910 spin_lock_irqsave(&btv->s_lock,flags);
3912 /* deactivate stuff */
3913 memset(&new,0,sizeof(new));
3914 old = btv->curr;
3915 ovbi = btv->cvbi;
3916 btv->curr = new;
3917 btv->cvbi = NULL;
3918 btv->loop_irq = 0;
3919 bttv_buffer_activate_video(btv, &new);
3920 bttv_buffer_activate_vbi(btv, NULL);
3921 bttv_set_dma(btv, 0);
3923 /* wake up */
3924 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3925 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3927 /* cancel all outstanding capture / vbi requests */
3928 while (!list_empty(&btv->capture)) {
3929 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3930 list_del(&item->vb.queue);
3931 item->vb.state = VIDEOBUF_ERROR;
3932 wake_up(&item->vb.done);
3934 while (!list_empty(&btv->vcapture)) {
3935 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3936 list_del(&item->vb.queue);
3937 item->vb.state = VIDEOBUF_ERROR;
3938 wake_up(&item->vb.done);
3941 btv->errors++;
3942 spin_unlock_irqrestore(&btv->s_lock,flags);
3945 static void
3946 bttv_irq_wakeup_top(struct bttv *btv)
3948 struct bttv_buffer *wakeup = btv->curr.top;
3950 if (NULL == wakeup)
3951 return;
3953 spin_lock(&btv->s_lock);
3954 btv->curr.top_irq = 0;
3955 btv->curr.top = NULL;
3956 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3958 do_gettimeofday(&wakeup->vb.ts);
3959 wakeup->vb.field_count = btv->field_count;
3960 wakeup->vb.state = VIDEOBUF_DONE;
3961 wake_up(&wakeup->vb.done);
3962 spin_unlock(&btv->s_lock);
3965 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3967 if (rc < risc->dma)
3968 return 0;
3969 if (rc > risc->dma + risc->size)
3970 return 0;
3971 return 1;
3974 static void
3975 bttv_irq_switch_video(struct bttv *btv)
3977 struct bttv_buffer_set new;
3978 struct bttv_buffer_set old;
3979 dma_addr_t rc;
3981 spin_lock(&btv->s_lock);
3983 /* new buffer set */
3984 bttv_irq_next_video(btv, &new);
3985 rc = btread(BT848_RISC_COUNT);
3986 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3987 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3988 btv->framedrop++;
3989 if (debug_latency)
3990 bttv_irq_debug_low_latency(btv, rc);
3991 spin_unlock(&btv->s_lock);
3992 return;
3995 /* switch over */
3996 old = btv->curr;
3997 btv->curr = new;
3998 btv->loop_irq &= ~1;
3999 bttv_buffer_activate_video(btv, &new);
4000 bttv_set_dma(btv, 0);
4002 /* switch input */
4003 if (UNSET != btv->new_input) {
4004 video_mux(btv,btv->new_input);
4005 btv->new_input = UNSET;
4008 /* wake up finished buffers */
4009 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4010 spin_unlock(&btv->s_lock);
4013 static void
4014 bttv_irq_switch_vbi(struct bttv *btv)
4016 struct bttv_buffer *new = NULL;
4017 struct bttv_buffer *old;
4018 u32 rc;
4020 spin_lock(&btv->s_lock);
4022 if (!list_empty(&btv->vcapture))
4023 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4024 old = btv->cvbi;
4026 rc = btread(BT848_RISC_COUNT);
4027 if (NULL != old && (is_active(&old->top, rc) ||
4028 is_active(&old->bottom, rc))) {
4029 btv->framedrop++;
4030 if (debug_latency)
4031 bttv_irq_debug_low_latency(btv, rc);
4032 spin_unlock(&btv->s_lock);
4033 return;
4036 /* switch */
4037 btv->cvbi = new;
4038 btv->loop_irq &= ~4;
4039 bttv_buffer_activate_vbi(btv, new);
4040 bttv_set_dma(btv, 0);
4042 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4043 spin_unlock(&btv->s_lock);
4046 static irqreturn_t bttv_irq(int irq, void *dev_id)
4048 u32 stat,astat;
4049 u32 dstat;
4050 int count;
4051 struct bttv *btv;
4052 int handled = 0;
4054 btv=(struct bttv *)dev_id;
4056 if (btv->custom_irq)
4057 handled = btv->custom_irq(btv);
4059 count=0;
4060 while (1) {
4061 /* get/clear interrupt status bits */
4062 stat=btread(BT848_INT_STAT);
4063 astat=stat&btread(BT848_INT_MASK);
4064 if (!astat)
4065 break;
4066 handled = 1;
4067 btwrite(stat,BT848_INT_STAT);
4069 /* get device status bits */
4070 dstat=btread(BT848_DSTATUS);
4072 if (irq_debug) {
4073 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4074 "riscs=%x, riscc=%08x, ",
4075 btv->c.nr, count, btv->field_count,
4076 stat>>28, btread(BT848_RISC_COUNT));
4077 bttv_print_irqbits(stat,astat);
4078 if (stat & BT848_INT_HLOCK)
4079 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4080 ? "yes" : "no");
4081 if (stat & BT848_INT_VPRES)
4082 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4083 ? "yes" : "no");
4084 if (stat & BT848_INT_FMTCHG)
4085 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4086 ? "625" : "525");
4087 printk("\n");
4090 if (astat&BT848_INT_VSYNC)
4091 btv->field_count++;
4093 if ((astat & BT848_INT_GPINT) && btv->remote) {
4094 wake_up(&btv->gpioq);
4095 bttv_input_irq(btv);
4098 if (astat & BT848_INT_I2CDONE) {
4099 btv->i2c_done = stat;
4100 wake_up(&btv->i2c_queue);
4103 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4104 bttv_irq_switch_vbi(btv);
4106 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4107 bttv_irq_wakeup_top(btv);
4109 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4110 bttv_irq_switch_video(btv);
4112 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4113 audio_mute(btv, btv->mute); /* trigger automute */
4115 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4116 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4117 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4118 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4119 btread(BT848_RISC_COUNT));
4120 bttv_print_irqbits(stat,astat);
4121 printk("\n");
4122 if (bttv_debug)
4123 bttv_print_riscaddr(btv);
4125 if (fdsr && astat & BT848_INT_FDSR) {
4126 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4127 btv->c.nr,btread(BT848_RISC_COUNT));
4128 if (bttv_debug)
4129 bttv_print_riscaddr(btv);
4132 count++;
4133 if (count > 4) {
4135 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4136 btwrite(0, BT848_INT_MASK);
4138 printk(KERN_ERR
4139 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4140 } else {
4141 printk(KERN_ERR
4142 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4144 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4145 BT848_INT_MASK);
4148 bttv_print_irqbits(stat,astat);
4150 printk("]\n");
4153 btv->irq_total++;
4154 if (handled)
4155 btv->irq_me++;
4156 return IRQ_RETVAL(handled);
4160 /* ----------------------------------------------------------------------- */
4161 /* initialitation */
4163 static struct video_device *vdev_init(struct bttv *btv,
4164 const struct video_device *template,
4165 const char *type_name)
4167 struct video_device *vfd;
4169 vfd = video_device_alloc();
4170 if (NULL == vfd)
4171 return NULL;
4172 *vfd = *template;
4173 vfd->v4l2_dev = &btv->c.v4l2_dev;
4174 vfd->release = video_device_release;
4175 vfd->debug = bttv_debug;
4176 video_set_drvdata(vfd, btv);
4177 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4178 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4179 type_name, bttv_tvcards[btv->c.type].name);
4180 return vfd;
4183 static void bttv_unregister_video(struct bttv *btv)
4185 if (btv->video_dev) {
4186 if (-1 != btv->video_dev->minor)
4187 video_unregister_device(btv->video_dev);
4188 else
4189 video_device_release(btv->video_dev);
4190 btv->video_dev = NULL;
4192 if (btv->vbi_dev) {
4193 if (-1 != btv->vbi_dev->minor)
4194 video_unregister_device(btv->vbi_dev);
4195 else
4196 video_device_release(btv->vbi_dev);
4197 btv->vbi_dev = NULL;
4199 if (btv->radio_dev) {
4200 if (-1 != btv->radio_dev->minor)
4201 video_unregister_device(btv->radio_dev);
4202 else
4203 video_device_release(btv->radio_dev);
4204 btv->radio_dev = NULL;
4208 /* register video4linux devices */
4209 static int __devinit bttv_register_video(struct bttv *btv)
4211 if (no_overlay > 0)
4212 printk("bttv: Overlay support disabled.\n");
4214 /* video */
4215 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4217 if (NULL == btv->video_dev)
4218 goto err;
4219 if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4220 video_nr[btv->c.nr]) < 0)
4221 goto err;
4222 printk(KERN_INFO "bttv%d: registered device video%d\n",
4223 btv->c.nr, btv->video_dev->num);
4224 if (device_create_file(&btv->video_dev->dev,
4225 &dev_attr_card)<0) {
4226 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4227 "failed\n", btv->c.nr);
4228 goto err;
4231 /* vbi */
4232 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4234 if (NULL == btv->vbi_dev)
4235 goto err;
4236 if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4237 vbi_nr[btv->c.nr]) < 0)
4238 goto err;
4239 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4240 btv->c.nr, btv->vbi_dev->num);
4242 if (!btv->has_radio)
4243 return 0;
4244 /* radio */
4245 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4246 if (NULL == btv->radio_dev)
4247 goto err;
4248 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4249 radio_nr[btv->c.nr]) < 0)
4250 goto err;
4251 printk(KERN_INFO "bttv%d: registered device radio%d\n",
4252 btv->c.nr, btv->radio_dev->num);
4254 /* all done */
4255 return 0;
4257 err:
4258 bttv_unregister_video(btv);
4259 return -1;
4263 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4264 /* response on cards with no firmware is not enabled by OF */
4265 static void pci_set_command(struct pci_dev *dev)
4267 #if defined(__powerpc__)
4268 unsigned int cmd;
4270 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4271 cmd = (cmd | PCI_COMMAND_MEMORY );
4272 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4273 #endif
4276 static int __devinit bttv_probe(struct pci_dev *dev,
4277 const struct pci_device_id *pci_id)
4279 int result;
4280 unsigned char lat;
4281 struct bttv *btv;
4283 if (bttv_num == BTTV_MAX)
4284 return -ENOMEM;
4285 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4286 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4287 if (btv == NULL) {
4288 printk(KERN_ERR "bttv: out of memory.\n");
4289 return -ENOMEM;
4291 btv->c.nr = bttv_num;
4292 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4293 "bttv%d", btv->c.nr);
4295 /* initialize structs / fill in defaults */
4296 mutex_init(&btv->lock);
4297 spin_lock_init(&btv->s_lock);
4298 spin_lock_init(&btv->gpio_lock);
4299 init_waitqueue_head(&btv->gpioq);
4300 init_waitqueue_head(&btv->i2c_queue);
4301 INIT_LIST_HEAD(&btv->c.subs);
4302 INIT_LIST_HEAD(&btv->capture);
4303 INIT_LIST_HEAD(&btv->vcapture);
4304 v4l2_prio_init(&btv->prio);
4306 init_timer(&btv->timeout);
4307 btv->timeout.function = bttv_irq_timeout;
4308 btv->timeout.data = (unsigned long)btv;
4310 btv->i2c_rc = -1;
4311 btv->tuner_type = UNSET;
4312 btv->new_input = UNSET;
4313 btv->has_radio=radio[btv->c.nr];
4315 /* pci stuff (init, get irq/mmio, ... */
4316 btv->c.pci = dev;
4317 btv->id = dev->device;
4318 if (pci_enable_device(dev)) {
4319 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4320 btv->c.nr);
4321 return -EIO;
4323 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4324 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4325 btv->c.nr);
4326 return -EIO;
4328 if (!request_mem_region(pci_resource_start(dev,0),
4329 pci_resource_len(dev,0),
4330 btv->c.v4l2_dev.name)) {
4331 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4332 btv->c.nr,
4333 (unsigned long long)pci_resource_start(dev,0));
4334 return -EBUSY;
4336 pci_set_master(dev);
4337 pci_set_command(dev);
4339 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4340 if (result < 0) {
4341 printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
4342 goto fail0;
4345 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4346 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4347 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4348 bttv_num,btv->id, btv->revision, pci_name(dev));
4349 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4350 btv->c.pci->irq, lat,
4351 (unsigned long long)pci_resource_start(dev,0));
4352 schedule();
4354 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4355 if (NULL == btv->bt848_mmio) {
4356 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4357 result = -EIO;
4358 goto fail1;
4361 /* identify card */
4362 bttv_idcard(btv);
4364 /* disable irqs, register irq handler */
4365 btwrite(0, BT848_INT_MASK);
4366 result = request_irq(btv->c.pci->irq, bttv_irq,
4367 IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4368 if (result < 0) {
4369 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4370 bttv_num,btv->c.pci->irq);
4371 goto fail1;
4374 if (0 != bttv_handle_chipset(btv)) {
4375 result = -EIO;
4376 goto fail2;
4379 /* init options from insmod args */
4380 btv->opt_combfilter = combfilter;
4381 btv->opt_lumafilter = lumafilter;
4382 btv->opt_automute = automute;
4383 btv->opt_chroma_agc = chroma_agc;
4384 btv->opt_adc_crush = adc_crush;
4385 btv->opt_vcr_hack = vcr_hack;
4386 btv->opt_whitecrush_upper = whitecrush_upper;
4387 btv->opt_whitecrush_lower = whitecrush_lower;
4388 btv->opt_uv_ratio = uv_ratio;
4389 btv->opt_full_luma_range = full_luma_range;
4390 btv->opt_coring = coring;
4392 /* fill struct bttv with some useful defaults */
4393 btv->init.btv = btv;
4394 btv->init.ov.w.width = 320;
4395 btv->init.ov.w.height = 240;
4396 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4397 btv->init.width = 320;
4398 btv->init.height = 240;
4399 btv->input = 0;
4401 /* initialize hardware */
4402 if (bttv_gpio)
4403 bttv_gpio_tracking(btv,"pre-init");
4405 bttv_risc_init_main(btv);
4406 init_bt848(btv);
4408 /* gpio */
4409 btwrite(0x00, BT848_GPIO_REG_INP);
4410 btwrite(0x00, BT848_GPIO_OUT_EN);
4411 if (bttv_verbose)
4412 bttv_gpio_tracking(btv,"init");
4414 /* needs to be done before i2c is registered */
4415 bttv_init_card1(btv);
4417 /* register i2c + gpio */
4418 init_bttv_i2c(btv);
4420 /* some card-specific stuff (needs working i2c) */
4421 bttv_init_card2(btv);
4422 bttv_init_tuner(btv);
4423 init_irqreg(btv);
4425 /* register video4linux + input */
4426 if (!bttv_tvcards[btv->c.type].no_video) {
4427 bttv_register_video(btv);
4428 bt848_bright(btv,32768);
4429 bt848_contrast(btv,32768);
4430 bt848_hue(btv,32768);
4431 bt848_sat(btv,32768);
4432 audio_mute(btv, 1);
4433 set_input(btv, 0, btv->tvnorm);
4434 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4435 btv->crop[1] = btv->crop[0]; /* current = default */
4436 disclaim_vbi_lines(btv);
4437 disclaim_video_lines(btv);
4440 /* add subdevices and autoload dvb-bt8xx if needed */
4441 if (bttv_tvcards[btv->c.type].has_dvb) {
4442 bttv_sub_add_device(&btv->c, "dvb");
4443 request_modules(btv);
4446 bttv_input_init(btv);
4448 /* everything is fine */
4449 bttv_num++;
4450 return 0;
4452 fail2:
4453 free_irq(btv->c.pci->irq,btv);
4455 fail1:
4456 v4l2_device_unregister(&btv->c.v4l2_dev);
4458 fail0:
4459 if (btv->bt848_mmio)
4460 iounmap(btv->bt848_mmio);
4461 release_mem_region(pci_resource_start(btv->c.pci,0),
4462 pci_resource_len(btv->c.pci,0));
4463 return result;
4466 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4468 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4469 struct bttv *btv = to_bttv(v4l2_dev);
4471 if (bttv_verbose)
4472 printk("bttv%d: unloading\n",btv->c.nr);
4474 /* shutdown everything (DMA+IRQs) */
4475 btand(~15, BT848_GPIO_DMA_CTL);
4476 btwrite(0, BT848_INT_MASK);
4477 btwrite(~0x0, BT848_INT_STAT);
4478 btwrite(0x0, BT848_GPIO_OUT_EN);
4479 if (bttv_gpio)
4480 bttv_gpio_tracking(btv,"cleanup");
4482 /* tell gpio modules we are leaving ... */
4483 btv->shutdown=1;
4484 wake_up(&btv->gpioq);
4485 bttv_input_fini(btv);
4486 bttv_sub_del_devices(&btv->c);
4488 /* unregister i2c_bus + input */
4489 fini_bttv_i2c(btv);
4491 /* unregister video4linux */
4492 bttv_unregister_video(btv);
4494 /* free allocated memory */
4495 btcx_riscmem_free(btv->c.pci,&btv->main);
4497 /* free ressources */
4498 free_irq(btv->c.pci->irq,btv);
4499 iounmap(btv->bt848_mmio);
4500 release_mem_region(pci_resource_start(btv->c.pci,0),
4501 pci_resource_len(btv->c.pci,0));
4503 v4l2_device_unregister(&btv->c.v4l2_dev);
4504 bttvs[btv->c.nr] = NULL;
4505 kfree(btv);
4507 return;
4510 #ifdef CONFIG_PM
4511 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4513 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4514 struct bttv *btv = to_bttv(v4l2_dev);
4515 struct bttv_buffer_set idle;
4516 unsigned long flags;
4518 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4520 /* stop dma + irqs */
4521 spin_lock_irqsave(&btv->s_lock,flags);
4522 memset(&idle, 0, sizeof(idle));
4523 btv->state.video = btv->curr;
4524 btv->state.vbi = btv->cvbi;
4525 btv->state.loop_irq = btv->loop_irq;
4526 btv->curr = idle;
4527 btv->loop_irq = 0;
4528 bttv_buffer_activate_video(btv, &idle);
4529 bttv_buffer_activate_vbi(btv, NULL);
4530 bttv_set_dma(btv, 0);
4531 btwrite(0, BT848_INT_MASK);
4532 spin_unlock_irqrestore(&btv->s_lock,flags);
4534 /* save bt878 state */
4535 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4536 btv->state.gpio_data = gpio_read();
4538 /* save pci state */
4539 pci_save_state(pci_dev);
4540 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4541 pci_disable_device(pci_dev);
4542 btv->state.disabled = 1;
4544 return 0;
4547 static int bttv_resume(struct pci_dev *pci_dev)
4549 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4550 struct bttv *btv = to_bttv(v4l2_dev);
4551 unsigned long flags;
4552 int err;
4554 dprintk("bttv%d: resume\n", btv->c.nr);
4556 /* restore pci state */
4557 if (btv->state.disabled) {
4558 err=pci_enable_device(pci_dev);
4559 if (err) {
4560 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4561 btv->c.nr);
4562 return err;
4564 btv->state.disabled = 0;
4566 err=pci_set_power_state(pci_dev, PCI_D0);
4567 if (err) {
4568 pci_disable_device(pci_dev);
4569 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4570 btv->c.nr);
4571 btv->state.disabled = 1;
4572 return err;
4575 pci_restore_state(pci_dev);
4577 /* restore bt878 state */
4578 bttv_reinit_bt848(btv);
4579 gpio_inout(0xffffff, btv->state.gpio_enable);
4580 gpio_write(btv->state.gpio_data);
4582 /* restart dma */
4583 spin_lock_irqsave(&btv->s_lock,flags);
4584 btv->curr = btv->state.video;
4585 btv->cvbi = btv->state.vbi;
4586 btv->loop_irq = btv->state.loop_irq;
4587 bttv_buffer_activate_video(btv, &btv->curr);
4588 bttv_buffer_activate_vbi(btv, btv->cvbi);
4589 bttv_set_dma(btv, 0);
4590 spin_unlock_irqrestore(&btv->s_lock,flags);
4591 return 0;
4593 #endif
4595 static struct pci_device_id bttv_pci_tbl[] = {
4596 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4597 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4598 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4599 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4600 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4601 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4602 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4603 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4604 {0,}
4607 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4609 static struct pci_driver bttv_pci_driver = {
4610 .name = "bttv",
4611 .id_table = bttv_pci_tbl,
4612 .probe = bttv_probe,
4613 .remove = __devexit_p(bttv_remove),
4614 #ifdef CONFIG_PM
4615 .suspend = bttv_suspend,
4616 .resume = bttv_resume,
4617 #endif
4620 static int __init bttv_init_module(void)
4622 int ret;
4624 bttv_num = 0;
4626 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4627 (BTTV_VERSION_CODE >> 16) & 0xff,
4628 (BTTV_VERSION_CODE >> 8) & 0xff,
4629 BTTV_VERSION_CODE & 0xff);
4630 #ifdef SNAPSHOT
4631 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4632 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4633 #endif
4634 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4635 gbuffers = 2;
4636 if (gbufsize > BTTV_MAX_FBUF)
4637 gbufsize = BTTV_MAX_FBUF;
4638 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4639 if (bttv_verbose)
4640 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4641 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4643 bttv_check_chipset();
4645 ret = bus_register(&bttv_sub_bus_type);
4646 if (ret < 0) {
4647 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4648 return ret;
4650 ret = pci_register_driver(&bttv_pci_driver);
4651 if (ret < 0)
4652 bus_unregister(&bttv_sub_bus_type);
4654 return ret;
4657 static void __exit bttv_cleanup_module(void)
4659 pci_unregister_driver(&bttv_pci_driver);
4660 bus_unregister(&bttv_sub_bus_type);
4663 module_init(bttv_init_module);
4664 module_exit(bttv_cleanup_module);
4667 * Local variables:
4668 * c-basic-offset: 8
4669 * End: