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