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