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