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