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