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