]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/media/pci/bt8xx/bttv-driver.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'mac80211-next-for-davem-2015-05-19' of git://git.kernel.org/pub/scm/linux...
[mirror_ubuntu-artful-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 =
f90580ca 1129 (max_t(unsigned int, 48, c->rect.width >> 4) + 3) & ~3;
e5bd0260 1130 c->min_scaled_height =
f90580ca 1131 max_t(unsigned int, 32, c->rect.height >> 4);
e5bd0260
MS		 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;
8774bed9 1185 bttv_call_all(btv, video, 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;
1da177e4 1534
8af443e5 1535 dprintk("switch_overlay: enter [new=%p]\n", new);
1da177e4 1536 if (new)
0fc0686e 1537 new->vb.state = VIDEOBUF_DONE;
1da177e4
LT		 1538 spin_lock_irqsave(&btv->s_lock,flags);
1539 old = btv->screen;
1540 btv->screen = new;
1541 btv->loop_irq |= 1;
1542 bttv_set_dma(btv, 0x03);
1543 spin_unlock_irqrestore(&btv->s_lock,flags);
1da177e4 1544 if (NULL != old) {
8af443e5
JP		 1545 dprintk("switch_overlay: old=%p state is %d\n",
1546 old, old->vb.state);
c7b0ac05 1547 bttv_dma_free(&fh->cap,btv, old);
1da177e4
LT		 1548 kfree(old);
1549 }
e5bd0260 1550 if (NULL == new)
8822f0d6 1551 free_btres_lock(btv,fh,RESOURCE_OVERLAY);
1da177e4 1552 dprintk("switch_overlay: done\n");
a896dc7a 1553 return 0;
1da177e4
LT		 1554}
1555
1556/* ----------------------------------------------------------------------- */
1557/* video4linux (1) interface */
1558
c7b0ac05
MCC		 1559static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1560 struct bttv_buffer *buf,
4ac97914 1561 const struct bttv_format *fmt,
1da177e4
LT		 1562 unsigned int width, unsigned int height,
1563 enum v4l2_field field)
1564{
e5bd0260 1565 struct bttv_fh *fh = q->priv_data;
1da177e4 1566 int redo_dma_risc = 0;
e5bd0260
MS		 1567 struct bttv_crop c;
1568 int norm;
1da177e4
LT		 1569 int rc;
1570
1571 /* check settings */
1572 if (NULL == fmt)
1573 return -EINVAL;
1574 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1575 width = RAW_BPL;
1576 height = RAW_LINES*2;
1577 if (width*height > buf->vb.bsize)
1578 return -EINVAL;
1579 buf->vb.size = buf->vb.bsize;
e5bd0260
MS		 1580
1581 /* Make sure tvnorm and vbi_end remain consistent
1582 until we're done. */
e5bd0260
MS		 1583
1584 norm = btv->tvnorm;
1585
1586 /* In this mode capturing always starts at defrect.top
1587 (default VDELAY), ignoring cropping parameters. */
1588 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
e5bd0260
MS		 1589 return -EINVAL;
1590 }
1591
e5bd0260 1592 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1da177e4 1593 } else {
e5bd0260
MS		 1594 norm = btv->tvnorm;
1595 c = btv->crop[!!fh->do_crop];
1596
e5bd0260
MS		 1597 if (width < c.min_scaled_width ||
1598 width > c.max_scaled_width ||
1599 height < c.min_scaled_height)
1da177e4 1600 return -EINVAL;
e5bd0260
MS		 1601
1602 switch (field) {
1603 case V4L2_FIELD_TOP:
1604 case V4L2_FIELD_BOTTOM:
1605 case V4L2_FIELD_ALTERNATE:
1606 /* btv->crop counts frame lines. Max. scale
1607 factor is 16:1 for frames, 8:1 for fields. */
1608 if (height * 2 > c.max_scaled_height)
1609 return -EINVAL;
1610 break;
1611
1612 default:
1613 if (height > c.max_scaled_height)
1614 return -EINVAL;
1615 break;
1616 }
1617
1da177e4
LT		 1618 buf->vb.size = (width * height * fmt->depth) >> 3;
1619 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1620 return -EINVAL;
1621 }
1622
1623 /* alloc + fill struct bttv_buffer (if changed) */
1624 if (buf->vb.width != width || buf->vb.height != height ||
1625 buf->vb.field != field ||
e5bd0260
MS		 1626 buf->tvnorm != norm || buf->fmt != fmt ||
1627 buf->crop.top != c.rect.top ||
1628 buf->crop.left != c.rect.left ||
1629 buf->crop.width != c.rect.width ||
1630 buf->crop.height != c.rect.height) {
1da177e4
LT		 1631 buf->vb.width = width;
1632 buf->vb.height = height;
1633 buf->vb.field = field;
e5bd0260 1634 buf->tvnorm = norm;
1da177e4 1635 buf->fmt = fmt;
e5bd0260 1636 buf->crop = c.rect;
1da177e4
LT		 1637 redo_dma_risc = 1;
1638 }
1639
1640 /* alloc risc memory */
0fc0686e 1641 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1da177e4 1642 redo_dma_risc = 1;
c7b0ac05 1643 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1da177e4
LT		 1644 goto fail;
1645 }
1646
1647 if (redo_dma_risc)
1648 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1649 goto fail;
1650
0fc0686e 1651 buf->vb.state = VIDEOBUF_PREPARED;
1da177e4
LT		 1652 return 0;
1653
1654 fail:
c7b0ac05 1655 bttv_dma_free(q,btv,buf);
1da177e4
LT		 1656 return rc;
1657}
1658
1659static int
1660buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1661{
1662 struct bttv_fh *fh = q->priv_data;
1663
1664 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1665 if (0 == *count)
1666 *count = gbuffers;
dab7e310
AB		 1667 if (*size * *count > gbuffers * gbufsize)
1668 *count = (gbuffers * gbufsize) / *size;
1da177e4
LT		 1669 return 0;
1670}
1671
1672static int
1673buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1674 enum v4l2_field field)
1675{
1676 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1677 struct bttv_fh *fh = q->priv_data;
1678
c7b0ac05 1679 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1da177e4
LT		 1680 fh->width, fh->height, field);
1681}
1682
1683static void
1684buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1685{
1686 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1687 struct bttv_fh *fh = q->priv_data;
1688 struct bttv *btv = fh->btv;
1689
0fc0686e 1690 buf->vb.state = VIDEOBUF_QUEUED;
1da177e4
LT		 1691 list_add_tail(&buf->vb.queue,&btv->capture);
1692 if (!btv->curr.frame_irq) {
1693 btv->loop_irq |= 1;
1694 bttv_set_dma(btv, 0x03);
1695 }
1696}
1697
1698static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1699{
1700 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1701 struct bttv_fh *fh = q->priv_data;
1702
feaba7a9 1703 bttv_dma_free(q,fh->btv,buf);
1da177e4
LT		 1704}
1705
1706static struct videobuf_queue_ops bttv_video_qops = {
1707 .buf_setup = buffer_setup,
1708 .buf_prepare = buffer_prepare,
1709 .buf_queue = buffer_queue,
1710 .buf_release = buffer_release,
1711};
1712
b8e2a361
HV		 1713static void radio_enable(struct bttv *btv)
1714{
1715 /* Switch to the radio tuner */
1716 if (!btv->has_radio_tuner) {
1717 btv->has_radio_tuner = 1;
1718 bttv_call_all(btv, tuner, s_radio);
2166f0a9
FS		 1719 btv->audio_input = TVAUDIO_INPUT_RADIO;
1720 audio_input(btv, btv->audio_input);
b8e2a361
HV		 1721 }
1722}
1723
314527ac 1724static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id)
1da177e4 1725{
402aa76a
DSL		 1726 struct bttv_fh *fh = priv;
1727 struct bttv *btv = fh->btv;
1728 unsigned int i;
8c14cc1f 1729 int err = 0;
1da177e4 1730
402aa76a 1731 for (i = 0; i < BTTV_TVNORMS; i++)
314527ac 1732 if (id & bttv_tvnorms[i].v4l2_id)
402aa76a 1733 break;
c37db91f
MCC		 1734 if (i == BTTV_TVNORMS) {
1735 err = -EINVAL;
1736 goto err;
1737 }
1da177e4 1738
314527ac 1739 btv->std = id;
402aa76a 1740 set_tvnorm(btv, i);
c37db91f
MCC		 1741
1742err:
1da177e4 1743
c37db91f 1744 return err;
402aa76a 1745}
1da177e4 1746
6795cc55
HV		 1747static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id)
1748{
1749 struct bttv_fh *fh = priv;
1750 struct bttv *btv = fh->btv;
1751
1752 *id = btv->std;
1753 return 0;
1754}
1755
e5ae3db4 1756static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
402aa76a
DSL		 1757{
1758 struct bttv_fh *fh = f;
1759 struct bttv *btv = fh->btv;
1da177e4 1760
402aa76a 1761 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
0bde6c3e 1762 *id &= V4L2_STD_625_50;
402aa76a 1763 else
0bde6c3e 1764 *id &= V4L2_STD_525_60;
402aa76a
DSL		 1765 return 0;
1766}
1da177e4 1767
e5ae3db4 1768static int bttv_enum_input(struct file *file, void *priv,
402aa76a
DSL		 1769 struct v4l2_input *i)
1770{
1771 struct bttv_fh *fh = priv;
1772 struct bttv *btv = fh->btv;
c37db91f 1773 int rc = 0;
1da177e4 1774
c37db91f
MCC		 1775 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) {
1776 rc = -EINVAL;
1777 goto err;
1778 }
4b9b936f 1779
402aa76a 1780 i->type = V4L2_INPUT_TYPE_CAMERA;
f74f89cb 1781 i->audioset = 0;
1da177e4 1782
abb0362f 1783 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
402aa76a
DSL		 1784 sprintf(i->name, "Television");
1785 i->type = V4L2_INPUT_TYPE_TUNER;
1786 i->tuner = 0;
1787 } else if (i->index == btv->svhs) {
1788 sprintf(i->name, "S-Video");
1789 } else {
1790 sprintf(i->name, "Composite%d", i->index);
1da177e4 1791 }
1da177e4 1792
402aa76a
DSL		 1793 if (i->index == btv->input) {
1794 __u32 dstatus = btread(BT848_DSTATUS);
1795 if (0 == (dstatus & BT848_DSTATUS_PRES))
1796 i->status |= V4L2_IN_ST_NO_SIGNAL;
1797 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1798 i->status |= V4L2_IN_ST_NO_H_LOCK;
55c0d100 1799 }
1da177e4 1800
c37db91f 1801 i->std = BTTV_NORMS;
1da177e4 1802
c37db91f 1803err:
c37db91f
MCC		 1804
1805 return rc;
1da177e4
LT		 1806}
1807
e5ae3db4 1808static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
e5bd0260 1809{
402aa76a
DSL		 1810 struct bttv_fh *fh = priv;
1811 struct bttv *btv = fh->btv;
e5bd0260 1812
402aa76a 1813 *i = btv->input;
c37db91f 1814
402aa76a
DSL		 1815 return 0;
1816}
e5bd0260 1817
e5ae3db4 1818static int bttv_s_input(struct file *file, void *priv, unsigned int i)
402aa76a
DSL		 1819{
1820 struct bttv_fh *fh = priv;
1821 struct bttv *btv = fh->btv;
402aa76a 1822
f74f89cb
HV		 1823 if (i >= bttv_tvcards[btv->c.type].video_inputs)
1824 return -EINVAL;
402aa76a 1825
402aa76a 1826 set_input(btv, i, btv->tvnorm);
402aa76a
DSL		 1827 return 0;
1828}
1829
e5ae3db4 1830static int bttv_s_tuner(struct file *file, void *priv,
2f73c7c5 1831 const struct v4l2_tuner *t)
402aa76a
DSL		 1832{
1833 struct bttv_fh *fh = priv;
1834 struct bttv *btv = fh->btv;
402aa76a 1835
d9b67076 1836 if (t->index)
402aa76a
DSL		 1837 return -EINVAL;
1838
859f0277 1839 bttv_call_all(btv, tuner, s_tuner, t);
402aa76a 1840
2f73c7c5
HV		 1841 if (btv->audio_mode_gpio) {
1842 struct v4l2_tuner copy = *t;
1843
1844 btv->audio_mode_gpio(btv, &copy, 1);
1845 }
402aa76a
DSL		 1846 return 0;
1847}
1848
e5ae3db4 1849static int bttv_g_frequency(struct file *file, void *priv,
402aa76a
DSL		 1850 struct v4l2_frequency *f)
1851{
1852 struct bttv_fh *fh = priv;
1853 struct bttv *btv = fh->btv;
402aa76a 1854
d9b67076
HV		 1855 if (f->tuner)
1856 return -EINVAL;
402aa76a 1857
b8e2a361
HV		 1858 if (f->type == V4L2_TUNER_RADIO)
1859 radio_enable(btv);
76ea992a
HV		 1860 f->frequency = f->type == V4L2_TUNER_RADIO ?
1861 btv->radio_freq : btv->tv_freq;
1862
402aa76a
DSL		 1863 return 0;
1864}
1865
b530a447 1866static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f)
76ea992a 1867{
b530a447
HV		 1868 struct v4l2_frequency new_freq = *f;
1869
76ea992a
HV		 1870 bttv_call_all(btv, tuner, s_frequency, f);
1871 /* s_frequency may clamp the frequency, so get the actual
1872 frequency before assigning radio/tv_freq. */
b530a447
HV		 1873 bttv_call_all(btv, tuner, g_frequency, &new_freq);
1874 if (new_freq.type == V4L2_TUNER_RADIO) {
b8e2a361 1875 radio_enable(btv);
b530a447 1876 btv->radio_freq = new_freq.frequency;
1b500373
OZ		 1877 if (btv->has_tea575x) {
1878 btv->tea.freq = btv->radio_freq;
1879 snd_tea575x_set_freq(&btv->tea);
1880 }
76ea992a 1881 } else {
b530a447 1882 btv->tv_freq = new_freq.frequency;
76ea992a
HV		 1883 }
1884}
1885
e5ae3db4 1886static int bttv_s_frequency(struct file *file, void *priv,
b530a447 1887 const struct v4l2_frequency *f)
402aa76a
DSL		 1888{
1889 struct bttv_fh *fh = priv;
1890 struct bttv *btv = fh->btv;
402aa76a 1891
d9b67076 1892 if (f->tuner)
402aa76a 1893 return -EINVAL;
c37db91f 1894
76ea992a 1895 bttv_set_frequency(btv, f);
402aa76a
DSL		 1896 return 0;
1897}
1898
e5ae3db4 1899static int bttv_log_status(struct file *file, void *f)
402aa76a 1900{
01df530c 1901 struct video_device *vdev = video_devdata(file);
402aa76a
DSL		 1902 struct bttv_fh *fh = f;
1903 struct bttv *btv = fh->btv;
1904
01df530c 1905 v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name);
859f0277 1906 bttv_call_all(btv, core, log_status);
402aa76a
DSL		 1907 return 0;
1908}
1909
402aa76a 1910#ifdef CONFIG_VIDEO_ADV_DEBUG
e5ae3db4 1911static int bttv_g_register(struct file *file, void *f,
aecde8b5 1912 struct v4l2_dbg_register *reg)
402aa76a
DSL		 1913{
1914 struct bttv_fh *fh = f;
1915 struct bttv *btv = fh->btv;
1916
402aa76a
DSL		 1917 /* bt848 has a 12-bit register space */
1918 reg->reg &= 0xfff;
1919 reg->val = btread(reg->reg);
aecde8b5 1920 reg->size = 1;
402aa76a
DSL		 1921
1922 return 0;
1923}
1924
e5ae3db4 1925static int bttv_s_register(struct file *file, void *f,
977ba3b1 1926 const struct v4l2_dbg_register *reg)
402aa76a
DSL		 1927{
1928 struct bttv_fh *fh = f;
1929 struct bttv *btv = fh->btv;
1930
402aa76a 1931 /* bt848 has a 12-bit register space */
977ba3b1 1932 btwrite(reg->val, reg->reg & 0xfff);
402aa76a
DSL		 1933
1934 return 0;
1935}
1936#endif
1937
1938/* Given cropping boundaries b and the scaled width and height of a
1939 single field or frame, which must not exceed hardware limits, this
1940 function adjusts the cropping parameters c. */
1941static void
1942bttv_crop_adjust (struct bttv_crop * c,
1943 const struct v4l2_rect * b,
1944 __s32 width,
1945 __s32 height,
1946 enum v4l2_field field)
1947{
1948 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
1949 __s32 max_left;
1950 __s32 max_top;
1951
1952 if (width < c->min_scaled_width) {
1953 /* Max. hor. scale factor 16:1. */
1954 c->rect.width = width * 16;
1955 } else if (width > c->max_scaled_width) {
1956 /* Min. hor. scale factor 1:1. */
1957 c->rect.width = width;
1958
1959 max_left = b->left + b->width - width;
1960 max_left = min(max_left, (__s32) MAX_HDELAY);
1961 if (c->rect.left > max_left)
1962 c->rect.left = max_left;
1963 }
1964
1965 if (height < c->min_scaled_height) {
1966 /* Max. vert. scale factor 16:1, single fields 8:1. */
1967 c->rect.height = height * 16;
1968 } else if (frame_height > c->max_scaled_height) {
1969 /* Min. vert. scale factor 1:1.
1970 Top and height count field lines times two. */
1971 c->rect.height = (frame_height + 1) & ~1;
1972
1973 max_top = b->top + b->height - c->rect.height;
e5bd0260
MS		 1974 if (c->rect.top > max_top)
1975 c->rect.top = max_top;
1976 }
1977
1978 bttv_crop_calc_limits(c);
1979}
1980
1981/* Returns an error if scaling to a frame or single field with the given
1982 width and height is not possible with the current cropping parameters
1983 and width aligned according to width_mask. If adjust_size is TRUE the
1984 function may adjust the width and/or height instead, rounding width
1985 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
1986 also adjust the current cropping parameters to get closer to the
1987 desired image size. */
1988static int
8822f0d6 1989limit_scaled_size_lock (struct bttv_fh * fh,
e5bd0260
MS		 1990 __s32 * width,
1991 __s32 * height,
1992 enum v4l2_field field,
1993 unsigned int width_mask,
1994 unsigned int width_bias,
1995 int adjust_size,
1996 int adjust_crop)
1997{
1998 struct bttv *btv = fh->btv;
1999 const struct v4l2_rect *b;
2000 struct bttv_crop *c;
2001 __s32 min_width;
2002 __s32 min_height;
2003 __s32 max_width;
2004 __s32 max_height;
2005 int rc;
2006
2007 BUG_ON((int) width_mask >= 0 ||
2008 width_bias >= (unsigned int) -width_mask);
2009
2010 /* Make sure tvnorm, vbi_end and the current cropping parameters
2011 remain consistent until we're done. */
e5bd0260
MS		 2012
2013 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2014
2015 /* Do crop - use current, don't - use default parameters. */
2016 c = &btv->crop[!!fh->do_crop];
2017
2018 if (fh->do_crop
2019 && adjust_size
2020 && adjust_crop
2021 && !locked_btres(btv, VIDEO_RESOURCES)) {
2022 min_width = 48;
2023 min_height = 32;
2024
2025 /* We cannot scale up. When the scaled image is larger
2026 than crop.rect we adjust the crop.rect as required
2027 by the V4L2 spec, hence cropcap.bounds are our limit. */
f90580ca 2028 max_width = min_t(unsigned int, b->width, MAX_HACTIVE);
e5bd0260
MS		 2029 max_height = b->height;
2030
2031 /* We cannot capture the same line as video and VBI data.
2032 Note btv->vbi_end is really a minimum, see
2033 bttv_vbi_try_fmt(). */
2034 if (btv->vbi_end > b->top) {
2035 max_height -= btv->vbi_end - b->top;
2036 rc = -EBUSY;
2037 if (min_height > max_height)
2038 goto fail;
2039 }
2040 } else {
2041 rc = -EBUSY;
2042 if (btv->vbi_end > c->rect.top)
2043 goto fail;
2044
2045 min_width = c->min_scaled_width;
2046 min_height = c->min_scaled_height;
2047 max_width = c->max_scaled_width;
2048 max_height = c->max_scaled_height;
2049
2050 adjust_crop = 0;
2051 }
2052
2053 min_width = (min_width - width_mask - 1) & width_mask;
2054 max_width = max_width & width_mask;
2055
2056 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2057 min_height = min_height;
2058 /* Min. scale factor is 1:1. */
2059 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2060
2061 if (adjust_size) {
2062 *width = clamp(*width, min_width, max_width);
2063 *height = clamp(*height, min_height, max_height);
2064
2065 /* Round after clamping to avoid overflow. */
2066 *width = (*width + width_bias) & width_mask;
2067
2068 if (adjust_crop) {
2069 bttv_crop_adjust(c, b, *width, *height, field);
2070
2071 if (btv->vbi_end > c->rect.top) {
2072 /* Move the crop window out of the way. */
2073 c->rect.top = btv->vbi_end;
2074 }
2075 }
2076 } else {
2077 rc = -EINVAL;
2078 if (*width < min_width ||
2079 *height < min_height ||
2080 *width > max_width ||
2081 *height > max_height ||
2082 0 != (*width & ~width_mask))
2083 goto fail;
2084 }
2085
2086 rc = 0; /* success */
2087
2088 fail:
e5bd0260
MS		 2089
2090 return rc;
2091}
2092
2093/* Returns an error if the given overlay window dimensions are not
2094 possible with the current cropping parameters. If adjust_size is
2095 TRUE the function may adjust the window width and/or height
2096 instead, however it always rounds the horizontal position and
2097 width as btcx_align() does. If adjust_crop is TRUE the function
2098 may also adjust the current cropping parameters to get closer
2099 to the desired window size. */
2100static int
c13eb703
HV		 2101verify_window_lock(struct bttv_fh *fh, struct v4l2_window *win,
2102 int adjust_size, int adjust_crop)
1da177e4
LT		 2103{
2104 enum v4l2_field field;
e5bd0260
MS		 2105 unsigned int width_mask;
2106 int rc;
1da177e4 2107
c13eb703
HV		 2108 if (win->w.width < 48)
2109 win->w.width = 48;
2110 if (win->w.height < 32)
2111 win->w.height = 32;
1da177e4 2112 if (win->clipcount > 2048)
c13eb703 2113 win->clipcount = 2048;
1da177e4 2114
c13eb703
HV		 2115 win->chromakey = 0;
2116 win->global_alpha = 0;
1da177e4 2117 field = win->field;
1da177e4 2118
c13eb703
HV		 2119 switch (field) {
2120 case V4L2_FIELD_TOP:
2121 case V4L2_FIELD_BOTTOM:
2122 case V4L2_FIELD_INTERLACED:
2123 break;
2124 default:
2125 field = V4L2_FIELD_ANY;
2126 break;
2127 }
1da177e4 2128 if (V4L2_FIELD_ANY == field) {
e5bd0260
MS		 2129 __s32 height2;
2130
2131 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2132 field = (win->w.height > height2)
1da177e4
LT		 2133 ? V4L2_FIELD_INTERLACED
2134 : V4L2_FIELD_TOP;
2135 }
c13eb703 2136 win->field = field;
1da177e4 2137
e5bd0260 2138 if (NULL == fh->ovfmt)
1da177e4 2139 return -EINVAL;
c13eb703 2140 /* 4-byte alignment. */
e5bd0260
MS		 2141 width_mask = ~0;
2142 switch (fh->ovfmt->depth) {
2143 case 8:
2144 case 24:
2145 width_mask = ~3;
2146 break;
2147 case 16:
2148 width_mask = ~1;
2149 break;
2150 case 32:
2151 break;
2152 default:
2153 BUG();
2154 }
2155
2156 win->w.width -= win->w.left & ~width_mask;
2157 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2158
8822f0d6 2159 rc = limit_scaled_size_lock(fh, &win->w.width, &win->w.height,
e5bd0260
MS		 2160 field, width_mask,
2161 /* width_bias: round down */ 0,
2162 adjust_size, adjust_crop);
2163 if (0 != rc)
2164 return rc;
1da177e4
LT		 2165 return 0;
2166}
2167
8822f0d6 2168static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
1da177e4
LT		 2169 struct v4l2_window *win, int fixup)
2170{
2171 struct v4l2_clip *clips = NULL;
2172 int n,size,retval = 0;
2173
2174 if (NULL == fh->ovfmt)
2175 return -EINVAL;
2176 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2177 return -EINVAL;
8822f0d6 2178 retval = verify_window_lock(fh, win,
e5bd0260
MS		 2179 /* adjust_size */ fixup,
2180 /* adjust_crop */ fixup);
1da177e4
LT		 2181 if (0 != retval)
2182 return retval;
2183
2184 /* copy clips -- luckily v4l1 + v4l2 are binary
2185 compatible here ...*/
2186 n = win->clipcount;
2187 size = sizeof(*clips)*(n+4);
2188 clips = kmalloc(size,GFP_KERNEL);
2189 if (NULL == clips)
2190 return -ENOMEM;
2191 if (n > 0) {
2192 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2193 kfree(clips);
2194 return -EFAULT;
2195 }
2196 }
c37db91f 2197
1da177e4
LT		 2198 /* clip against screen */
2199 if (NULL != btv->fbuf.base)
2200 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2201 &win->w, clips, n);
2202 btcx_sort_clips(clips,n);
2203
2204 /* 4-byte alignments */
2205 switch (fh->ovfmt->depth) {
2206 case 8:
2207 case 24:
2208 btcx_align(&win->w, clips, n, 3);
2209 break;
2210 case 16:
2211 btcx_align(&win->w, clips, n, 1);
2212 break;
2213 case 32:
2214 /* no alignment fixups needed */
2215 break;
2216 default:
2217 BUG();
2218 }
2219
64f9477f 2220 kfree(fh->ov.clips);
1da177e4
LT		 2221 fh->ov.clips = clips;
2222 fh->ov.nclips = n;
2223
2224 fh->ov.w = win->w;
2225 fh->ov.field = win->field;
2226 fh->ov.setup_ok = 1;
c37db91f 2227
1da177e4
LT		 2228 btv->init.ov.w.width = win->w.width;
2229 btv->init.ov.w.height = win->w.height;
2230 btv->init.ov.field = win->field;
2231
2232 /* update overlay if needed */
2233 retval = 0;
2234 if (check_btres(fh, RESOURCE_OVERLAY)) {
2235 struct bttv_buffer *new;
2236
0705135e 2237 new = videobuf_sg_alloc(sizeof(*new));
e5bd0260 2238 new->crop = btv->crop[!!fh->do_crop].rect;
1da177e4
LT		 2239 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2240 retval = bttv_switch_overlay(btv,fh,new);
2241 }
1da177e4
LT		 2242 return retval;
2243}
2244
2245/* ----------------------------------------------------------------------- */
2246
2247static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2248{
2249 struct videobuf_queue* q = NULL;
2250
2251 switch (fh->type) {
2252 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2253 q = &fh->cap;
2254 break;
2255 case V4L2_BUF_TYPE_VBI_CAPTURE:
2256 q = &fh->vbi;
2257 break;
2258 default:
2259 BUG();
2260 }
2261 return q;
2262}
2263
2264static int bttv_resource(struct bttv_fh *fh)
2265{
2266 int res = 0;
2267
2268 switch (fh->type) {
2269 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
e5bd0260 2270 res = RESOURCE_VIDEO_STREAM;
1da177e4
LT		 2271 break;
2272 case V4L2_BUF_TYPE_VBI_CAPTURE:
2273 res = RESOURCE_VBI;
2274 break;
2275 default:
2276 BUG();
2277 }
2278 return res;
2279}
2280
2281static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2282{
2283 struct videobuf_queue *q = bttv_queue(fh);
2284 int res = bttv_resource(fh);
2285
2286 if (check_btres(fh,res))
2287 return -EBUSY;
2288 if (videobuf_queue_is_busy(q))
2289 return -EBUSY;
2290 fh->type = type;
2291 return 0;
2292}
2293
c87c948e
MS		 2294static void
2295pix_format_set_size (struct v4l2_pix_format * f,
2296 const struct bttv_format * fmt,
2297 unsigned int width,
2298 unsigned int height)
2299{
2300 f->width = width;
2301 f->height = height;
2302
2303 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2304 f->bytesperline = width; /* Y plane */
2305 f->sizeimage = (width * height * fmt->depth) >> 3;
2306 } else {
2307 f->bytesperline = (width * fmt->depth) >> 3;
2308 f->sizeimage = height * f->bytesperline;
2309 }
2310}
2311
78b526a4 2312static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
402aa76a 2313 struct v4l2_format *f)
1da177e4 2314{
402aa76a
DSL		 2315 struct bttv_fh *fh = priv;
2316
2317 pix_format_set_size(&f->fmt.pix, fh->fmt,
2318 fh->width, fh->height);
2319 f->fmt.pix.field = fh->cap.field;
2320 f->fmt.pix.pixelformat = fh->fmt->fourcc;
f5864899 2321 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
402aa76a
DSL		 2322
2323 return 0;
1da177e4
LT		 2324}
2325
78b526a4 2326static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
402aa76a 2327 struct v4l2_format *f)
1da177e4 2328{
402aa76a 2329 struct bttv_fh *fh = priv;
1da177e4 2330
402aa76a
DSL		 2331 f->fmt.win.w = fh->ov.w;
2332 f->fmt.win.field = fh->ov.field;
1da177e4 2333
402aa76a
DSL		 2334 return 0;
2335}
e5bd0260 2336
78b526a4 2337static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
402aa76a
DSL		 2338 struct v4l2_format *f)
2339{
2340 const struct bttv_format *fmt;
2341 struct bttv_fh *fh = priv;
2342 struct bttv *btv = fh->btv;
2343 enum v4l2_field field;
2344 __s32 width, height;
ee70e3d8 2345 __s32 height2;
9134be03 2346 int rc;
1da177e4 2347
402aa76a
DSL		 2348 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2349 if (NULL == fmt)
2350 return -EINVAL;
e5bd0260 2351
402aa76a 2352 field = f->fmt.pix.field;
e5bd0260 2353
402aa76a
DSL		 2354 switch (field) {
2355 case V4L2_FIELD_TOP:
2356 case V4L2_FIELD_BOTTOM:
2357 case V4L2_FIELD_ALTERNATE:
2358 case V4L2_FIELD_INTERLACED:
2359 break;
ee70e3d8 2360 case V4L2_FIELD_SEQ_BT:
402aa76a 2361 case V4L2_FIELD_SEQ_TB:
ee70e3d8
HV		 2362 if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) {
2363 field = V4L2_FIELD_SEQ_TB;
2364 break;
2365 }
2366 /* fall through */
2367 default: /* FIELD_ANY case */
2368 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2369 field = (f->fmt.pix.height > height2)
2370 ? V4L2_FIELD_INTERLACED
2371 : V4L2_FIELD_BOTTOM;
402aa76a 2372 break;
1da177e4 2373 }
402aa76a
DSL		 2374
2375 width = f->fmt.pix.width;
2376 height = f->fmt.pix.height;
2377
8822f0d6 2378 rc = limit_scaled_size_lock(fh, &width, &height, field,
9134be03
MCC		 2379 /* width_mask: 4 pixels */ ~3,
2380 /* width_bias: nearest */ 2,
2381 /* adjust_size */ 1,
2382 /* adjust_crop */ 0);
2383 if (0 != rc)
2384 return rc;
2385
402aa76a
DSL		 2386 /* update data for the application */
2387 f->fmt.pix.field = field;
2388 pix_format_set_size(&f->fmt.pix, fmt, width, height);
f5864899 2389 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
402aa76a
DSL		 2390
2391 return 0;
2392}
2393
78b526a4 2394static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
402aa76a
DSL		 2395 struct v4l2_format *f)
2396{
2397 struct bttv_fh *fh = priv;
2398
c13eb703 2399 verify_window_lock(fh, &f->fmt.win,
402aa76a
DSL		 2400 /* adjust_size */ 1,
2401 /* adjust_crop */ 0);
c13eb703 2402 return 0;
1da177e4
LT		 2403}
2404
78b526a4 2405static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
402aa76a 2406 struct v4l2_format *f)
1da177e4
LT		 2407{
2408 int retval;
402aa76a
DSL		 2409 const struct bttv_format *fmt;
2410 struct bttv_fh *fh = priv;
2411 struct bttv *btv = fh->btv;
9134be03
MCC		 2412 __s32 width, height;
2413 enum v4l2_field field;
1da177e4 2414
402aa76a
DSL		 2415 retval = bttv_switch_type(fh, f->type);
2416 if (0 != retval)
2417 return retval;
1da177e4 2418
78b526a4 2419 retval = bttv_try_fmt_vid_cap(file, priv, f);
402aa76a
DSL		 2420 if (0 != retval)
2421 return retval;
1da177e4 2422
9134be03
MCC		 2423 width = f->fmt.pix.width;
2424 height = f->fmt.pix.height;
2425 field = f->fmt.pix.field;
2426
8822f0d6 2427 retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field,
9134be03
MCC		 2428 /* width_mask: 4 pixels */ ~3,
2429 /* width_bias: nearest */ 2,
2430 /* adjust_size */ 1,
2431 /* adjust_crop */ 1);
2432 if (0 != retval)
2433 return retval;
2434
2435 f->fmt.pix.field = field;
2436
402aa76a 2437 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1da177e4 2438
402aa76a 2439 /* update our state informations */
402aa76a
DSL		 2440 fh->fmt = fmt;
2441 fh->cap.field = f->fmt.pix.field;
2442 fh->cap.last = V4L2_FIELD_NONE;
2443 fh->width = f->fmt.pix.width;
2444 fh->height = f->fmt.pix.height;
2445 btv->init.fmt = fmt;
2446 btv->init.width = f->fmt.pix.width;
2447 btv->init.height = f->fmt.pix.height;
402aa76a
DSL		 2448
2449 return 0;
2450}
2451
78b526a4 2452static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
402aa76a
DSL		 2453 struct v4l2_format *f)
2454{
2455 struct bttv_fh *fh = priv;
2456 struct bttv *btv = fh->btv;
2457
9134be03 2458 if (no_overlay > 0) {
8af443e5 2459 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
1da177e4 2460 return -EINVAL;
9134be03 2461 }
402aa76a 2462
8822f0d6 2463 return setup_window_lock(fh, btv, &f->fmt.win, 1);
402aa76a
DSL		 2464}
2465
e5ae3db4 2466static int bttv_querycap(struct file *file, void *priv,
402aa76a 2467 struct v4l2_capability *cap)
1da177e4 2468{
78dea1ae 2469 struct video_device *vdev = video_devdata(file);
402aa76a
DSL		 2470 struct bttv_fh *fh = priv;
2471 struct bttv *btv = fh->btv;
1da177e4 2472
402aa76a
DSL		 2473 if (0 == v4l2)
2474 return -EINVAL;
5e453dc7 2475
402aa76a 2476 strlcpy(cap->driver, "bttv", sizeof(cap->driver));
23fb4c5e 2477 strlcpy(cap->card, btv->video_dev.name, sizeof(cap->card));
402aa76a
DSL		 2478 snprintf(cap->bus_info, sizeof(cap->bus_info),
2479 "PCI:%s", pci_name(btv->c.pci));
402aa76a
DSL		 2480 cap->capabilities =
2481 V4L2_CAP_VIDEO_CAPTURE |
402aa76a 2482 V4L2_CAP_READWRITE |
78dea1ae
HV		 2483 V4L2_CAP_STREAMING |
2484 V4L2_CAP_DEVICE_CAPS;
402aa76a
DSL		 2485 if (no_overlay <= 0)
2486 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
23fb4c5e 2487 if (video_is_registered(&btv->vbi_dev))
78dea1ae 2488 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
23fb4c5e 2489 if (video_is_registered(&btv->radio_dev))
78dea1ae 2490 cap->capabilities |= V4L2_CAP_RADIO;
402aa76a 2491
c37db91f
MCC		 2492 /*
2493 * No need to lock here: those vars are initialized during board
2494 * probe and remains untouched during the rest of the driver lifecycle
2495 */
2496 if (btv->has_saa6588)
2497 cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
abb0362f 2498 if (btv->tuner_type != TUNER_ABSENT)
402aa76a 2499 cap->capabilities |= V4L2_CAP_TUNER;
78dea1ae
HV		 2500 if (vdev->vfl_type == VFL_TYPE_GRABBER)
2501 cap->device_caps = cap->capabilities &
2502 (V4L2_CAP_VIDEO_CAPTURE |
2503 V4L2_CAP_READWRITE |
2504 V4L2_CAP_STREAMING |
2505 V4L2_CAP_VIDEO_OVERLAY |
2506 V4L2_CAP_TUNER);
2507 else if (vdev->vfl_type == VFL_TYPE_VBI)
2508 cap->device_caps = cap->capabilities &
2509 (V4L2_CAP_VBI_CAPTURE |
2510 V4L2_CAP_READWRITE |
2511 V4L2_CAP_STREAMING |
2512 V4L2_CAP_TUNER);
2513 else {
2514 cap->device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
2515 if (btv->has_saa6588)
2516 cap->device_caps |= V4L2_CAP_READWRITE |
2517 V4L2_CAP_RDS_CAPTURE;
35655bf8
OZ		 2518 if (btv->has_tea575x)
2519 cap->device_caps |= V4L2_CAP_HW_FREQ_SEEK;
78dea1ae 2520 }
402aa76a
DSL		 2521 return 0;
2522}
1da177e4 2523
9134be03
MCC		 2524static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2525{
2526 int index = -1, i;
2527
2528 for (i = 0; i < FORMATS; i++) {
2529 if (formats[i].fourcc != -1)
2530 index++;
2531 if ((unsigned int)index == f->index)
2532 break;
2533 }
2534 if (FORMATS == i)
2535 return -EINVAL;
2536
2537 f->pixelformat = formats[i].fourcc;
2538 strlcpy(f->description, formats[i].name, sizeof(f->description));
2539
2540 return i;
2541}
2542
78b526a4 2543static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
402aa76a
DSL		 2544 struct v4l2_fmtdesc *f)
2545{
9134be03 2546 int rc = bttv_enum_fmt_cap_ovr(f);
1da177e4 2547
9134be03
MCC		 2548 if (rc < 0)
2549 return rc;
1da177e4 2550
402aa76a
DSL		 2551 return 0;
2552}
49ee718e 2553
78b526a4 2554static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv,
402aa76a
DSL		 2555 struct v4l2_fmtdesc *f)
2556{
9134be03
MCC		 2557 int rc;
2558
402aa76a 2559 if (no_overlay > 0) {
8af443e5 2560 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
402aa76a 2561 return -EINVAL;
1da177e4 2562 }
1da177e4 2563
9134be03 2564 rc = bttv_enum_fmt_cap_ovr(f);
1da177e4 2565
9134be03
MCC		 2566 if (rc < 0)
2567 return rc;
1da177e4 2568
9134be03
MCC		 2569 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2570 return -EINVAL;
1da177e4 2571
402aa76a
DSL		 2572 return 0;
2573}
2574
e5ae3db4 2575static int bttv_g_fbuf(struct file *file, void *f,
402aa76a
DSL		 2576 struct v4l2_framebuffer *fb)
2577{
2578 struct bttv_fh *fh = f;
2579 struct bttv *btv = fh->btv;
2580
2581 *fb = btv->fbuf;
2582 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
a12fd70e 2583 fb->flags = V4L2_FBUF_FLAG_PRIMARY;
402aa76a
DSL		 2584 if (fh->ovfmt)
2585 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2586 return 0;
2587}
2588
e5ae3db4 2589static int bttv_overlay(struct file *file, void *f, unsigned int on)
402aa76a
DSL		 2590{
2591 struct bttv_fh *fh = f;
2592 struct bttv *btv = fh->btv;
2593 struct bttv_buffer *new;
c37db91f 2594 int retval = 0;
402aa76a
DSL		 2595
2596 if (on) {
2597 /* verify args */
c37db91f 2598 if (unlikely(!btv->fbuf.base)) {
402aa76a 2599 return -EINVAL;
c37db91f
MCC		 2600 }
2601 if (unlikely(!fh->ov.setup_ok)) {
8af443e5 2602 dprintk("%d: overlay: !setup_ok\n", btv->c.nr);
c37db91f 2603 retval = -EINVAL;
1da177e4 2604 }
c37db91f
MCC		 2605 if (retval)
2606 return retval;
1da177e4 2607 }
402aa76a 2608
8822f0d6 2609 if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
402aa76a
DSL		 2610 return -EBUSY;
2611
402aa76a
DSL		 2612 if (on) {
2613 fh->ov.tvnorm = btv->tvnorm;
0705135e 2614 new = videobuf_sg_alloc(sizeof(*new));
7c018804 2615 new->crop = btv->crop[!!fh->do_crop].rect;
402aa76a
DSL		 2616 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2617 } else {
2618 new = NULL;
1da177e4
LT		 2619 }
2620
402aa76a
DSL		 2621 /* switch over */
2622 retval = bttv_switch_overlay(btv, fh, new);
402aa76a
DSL		 2623 return retval;
2624}
2625
e5ae3db4 2626static int bttv_s_fbuf(struct file *file, void *f,
e6eb28c2 2627 const struct v4l2_framebuffer *fb)
402aa76a
DSL		 2628{
2629 struct bttv_fh *fh = f;
2630 struct bttv *btv = fh->btv;
2631 const struct bttv_format *fmt;
2632 int retval;
2633
2634 if (!capable(CAP_SYS_ADMIN) &&
2635 !capable(CAP_SYS_RAWIO))
2636 return -EPERM;
1da177e4 2637
402aa76a
DSL		 2638 /* check args */
2639 fmt = format_by_fourcc(fb->fmt.pixelformat);
2640 if (NULL == fmt)
2641 return -EINVAL;
2642 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2643 return -EINVAL;
2644
2645 retval = -EINVAL;
2646 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2647 __s32 width = fb->fmt.width;
2648 __s32 height = fb->fmt.height;
2649
8822f0d6 2650 retval = limit_scaled_size_lock(fh, &width, &height,
402aa76a
DSL		 2651 V4L2_FIELD_INTERLACED,
2652 /* width_mask */ ~3,
2653 /* width_bias */ 2,
2654 /* adjust_size */ 0,
2655 /* adjust_crop */ 0);
2656 if (0 != retval)
2657 return retval;
1da177e4 2658 }
e84619b1 2659
402aa76a 2660 /* ok, accept it */
402aa76a
DSL		 2661 btv->fbuf.base = fb->base;
2662 btv->fbuf.fmt.width = fb->fmt.width;
2663 btv->fbuf.fmt.height = fb->fmt.height;
2664 if (0 != fb->fmt.bytesperline)
2665 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2666 else
2667 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
e84619b1 2668
402aa76a
DSL		 2669 retval = 0;
2670 fh->ovfmt = fmt;
2671 btv->init.ovfmt = fmt;
2672 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2673 fh->ov.w.left = 0;
2674 fh->ov.w.top = 0;
2675 fh->ov.w.width = fb->fmt.width;
2676 fh->ov.w.height = fb->fmt.height;
2677 btv->init.ov.w.width = fb->fmt.width;
2678 btv->init.ov.w.height = fb->fmt.height;
2679 kfree(fh->ov.clips);
2680 fh->ov.clips = NULL;
2681 fh->ov.nclips = 0;
2682
2683 if (check_btres(fh, RESOURCE_OVERLAY)) {
2684 struct bttv_buffer *new;
e84619b1 2685
0705135e 2686 new = videobuf_sg_alloc(sizeof(*new));
402aa76a 2687 new->crop = btv->crop[!!fh->do_crop].rect;
e84619b1 2688 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
402aa76a 2689 retval = bttv_switch_overlay(btv, fh, new);
e84619b1 2690 }
e84619b1 2691 }
402aa76a
DSL		 2692 return retval;
2693}
1da177e4 2694
e5ae3db4 2695static int bttv_reqbufs(struct file *file, void *priv,
402aa76a
DSL		 2696 struct v4l2_requestbuffers *p)
2697{
2698 struct bttv_fh *fh = priv;
2699 return videobuf_reqbufs(bttv_queue(fh), p);
2700}
1da177e4 2701
e5ae3db4 2702static int bttv_querybuf(struct file *file, void *priv,
402aa76a
DSL		 2703 struct v4l2_buffer *b)
2704{
2705 struct bttv_fh *fh = priv;
2706 return videobuf_querybuf(bttv_queue(fh), b);
2707}
1da177e4 2708
e5ae3db4 2709static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
402aa76a
DSL		 2710{
2711 struct bttv_fh *fh = priv;
2712 struct bttv *btv = fh->btv;
2713 int res = bttv_resource(fh);
1da177e4 2714
8822f0d6 2715 if (!check_alloc_btres_lock(btv, fh, res))
402aa76a 2716 return -EBUSY;
e5bd0260 2717
402aa76a
DSL		 2718 return videobuf_qbuf(bttv_queue(fh), b);
2719}
1da177e4 2720
e5ae3db4 2721static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
402aa76a
DSL		 2722{
2723 struct bttv_fh *fh = priv;
2724 return videobuf_dqbuf(bttv_queue(fh), b,
2725 file->f_flags & O_NONBLOCK);
2726}
1da177e4 2727
e5ae3db4 2728static int bttv_streamon(struct file *file, void *priv,
402aa76a
DSL		 2729 enum v4l2_buf_type type)
2730{
2731 struct bttv_fh *fh = priv;
2732 struct bttv *btv = fh->btv;
2733 int res = bttv_resource(fh);
1da177e4 2734
8822f0d6 2735 if (!check_alloc_btres_lock(btv, fh, res))
402aa76a
DSL		 2736 return -EBUSY;
2737 return videobuf_streamon(bttv_queue(fh));
2738}
1da177e4 2739
4b9b936f 2740
e5ae3db4 2741static int bttv_streamoff(struct file *file, void *priv,
402aa76a
DSL		 2742 enum v4l2_buf_type type)
2743{
2744 struct bttv_fh *fh = priv;
2745 struct bttv *btv = fh->btv;
2746 int retval;
2747 int res = bttv_resource(fh);
4b9b936f 2748
e84619b1 2749
402aa76a
DSL		 2750 retval = videobuf_streamoff(bttv_queue(fh));
2751 if (retval < 0)
2752 return retval;
8822f0d6 2753 free_btres_lock(btv, fh, res);
402aa76a
DSL		 2754 return 0;
2755}
4b9b936f 2756
e5ae3db4 2757static int bttv_g_parm(struct file *file, void *f,
402aa76a
DSL		 2758 struct v4l2_streamparm *parm)
2759{
2760 struct bttv_fh *fh = f;
2761 struct bttv *btv = fh->btv;
e5bd0260 2762
a652ef60
HV		 2763 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2764 return -EINVAL;
2765 parm->parm.capture.readbuffers = gbuffers;
51f0b8d5
TP		 2766 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2767 &parm->parm.capture.timeperframe);
c37db91f 2768
402aa76a
DSL		 2769 return 0;
2770}
e5bd0260 2771
e5ae3db4 2772static int bttv_g_tuner(struct file *file, void *priv,
402aa76a
DSL		 2773 struct v4l2_tuner *t)
2774{
2775 struct bttv_fh *fh = priv;
2776 struct bttv *btv = fh->btv;
e5bd0260 2777
402aa76a
DSL		 2778 if (0 != t->index)
2779 return -EINVAL;
e5bd0260 2780
402aa76a 2781 t->rxsubchans = V4L2_TUNER_SUB_MONO;
3d4b8035 2782 t->capability = V4L2_TUNER_CAP_NORM;
859f0277 2783 bttv_call_all(btv, tuner, g_tuner, t);
402aa76a 2784 strcpy(t->name, "Television");
402aa76a
DSL		 2785 t->type = V4L2_TUNER_ANALOG_TV;
2786 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2787 t->signal = 0xffff;
2788
2789 if (btv->audio_mode_gpio)
2790 btv->audio_mode_gpio(btv, t, 0);
e5bd0260 2791
402aa76a
DSL		 2792 return 0;
2793}
e5bd0260 2794
e5ae3db4 2795static int bttv_cropcap(struct file *file, void *priv,
402aa76a
DSL		 2796 struct v4l2_cropcap *cap)
2797{
2798 struct bttv_fh *fh = priv;
2799 struct bttv *btv = fh->btv;
2800
2801 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2802 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2803 return -EINVAL;
2804
2805 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
2806
2807 return 0;
2808}
e5bd0260 2809
e5ae3db4 2810static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
402aa76a
DSL		 2811{
2812 struct bttv_fh *fh = f;
2813 struct bttv *btv = fh->btv;
2814
2815 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2816 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2817 return -EINVAL;
e5bd0260 2818
402aa76a
DSL		 2819 /* No fh->do_crop = 1; because btv->crop[1] may be
2820 inconsistent with fh->width or fh->height and apps
2821 do not expect a change here. */
e5bd0260 2822
402aa76a 2823 crop->c = btv->crop[!!fh->do_crop].rect;
e5bd0260 2824
402aa76a
DSL		 2825 return 0;
2826}
2827
4f996594 2828static int bttv_s_crop(struct file *file, void *f, const struct v4l2_crop *crop)
402aa76a
DSL		 2829{
2830 struct bttv_fh *fh = f;
2831 struct bttv *btv = fh->btv;
2832 const struct v4l2_rect *b;
2833 int retval;
2834 struct bttv_crop c;
2835 __s32 b_left;
2836 __s32 b_top;
2837 __s32 b_right;
2838 __s32 b_bottom;
e5bd0260 2839
402aa76a
DSL		 2840 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2841 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
2842 return -EINVAL;
e5bd0260 2843
402aa76a
DSL		 2844 /* Make sure tvnorm, vbi_end and the current cropping
2845 parameters remain consistent until we're done. Note
8822f0d6 2846 read() may change vbi_end in check_alloc_btres_lock(). */
402aa76a 2847 retval = -EBUSY;
e5bd0260 2848
402aa76a 2849 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
402aa76a
DSL		 2850 return retval;
2851 }
e5bd0260 2852
402aa76a 2853 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
e5bd0260 2854
402aa76a
DSL		 2855 b_left = b->left;
2856 b_right = b_left + b->width;
2857 b_bottom = b->top + b->height;
e5bd0260 2858
402aa76a
DSL		 2859 b_top = max(b->top, btv->vbi_end);
2860 if (b_top + 32 >= b_bottom) {
402aa76a
DSL		 2861 return retval;
2862 }
e5bd0260 2863
402aa76a 2864 /* Min. scaled size 48 x 32. */
4f996594 2865 c.rect.left = clamp_t(s32, crop->c.left, b_left, b_right - 48);
402aa76a 2866 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
e5bd0260 2867
4f996594 2868 c.rect.width = clamp_t(s32, crop->c.width,
402aa76a 2869 48, b_right - c.rect.left);
e5bd0260 2870
4f996594 2871 c.rect.top = clamp_t(s32, crop->c.top, b_top, b_bottom - 32);
402aa76a
DSL		 2872 /* Top and height must be a multiple of two. */
2873 c.rect.top = (c.rect.top + 1) & ~1;
e5bd0260 2874
4f996594 2875 c.rect.height = clamp_t(s32, crop->c.height,
402aa76a
DSL		 2876 32, b_bottom - c.rect.top);
2877 c.rect.height = (c.rect.height + 1) & ~1;
e5bd0260 2878
402aa76a 2879 bttv_crop_calc_limits(&c);
e5bd0260 2880
402aa76a
DSL		 2881 btv->crop[1] = c;
2882
402aa76a
DSL		 2883 fh->do_crop = 1;
2884
402aa76a
DSL		 2885 if (fh->width < c.min_scaled_width) {
2886 fh->width = c.min_scaled_width;
2887 btv->init.width = c.min_scaled_width;
2888 } else if (fh->width > c.max_scaled_width) {
2889 fh->width = c.max_scaled_width;
2890 btv->init.width = c.max_scaled_width;
e5bd0260
MS		 2891 }
2892
402aa76a
DSL		 2893 if (fh->height < c.min_scaled_height) {
2894 fh->height = c.min_scaled_height;
2895 btv->init.height = c.min_scaled_height;
2896 } else if (fh->height > c.max_scaled_height) {
2897 fh->height = c.max_scaled_height;
2898 btv->init.height = c.max_scaled_height;
1da177e4 2899 }
1da177e4 2900
402aa76a
DSL		 2901 return 0;
2902}
2903
1da177e4
LT		 2904static ssize_t bttv_read(struct file *file, char __user *data,
2905 size_t count, loff_t *ppos)
2906{
2907 struct bttv_fh *fh = file->private_data;
2908 int retval = 0;
2909
2910 if (fh->btv->errors)
2911 bttv_reinit_bt848(fh->btv);
8af443e5
JP		 2912 dprintk("%d: read count=%d type=%s\n",
2913 fh->btv->c.nr, (int)count, v4l2_type_names[fh->type]);
1da177e4
LT		 2914
2915 switch (fh->type) {
2916 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
8822f0d6 2917 if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) {
e5bd0260
MS		 2918 /* VIDEO_READ in use by another fh,
2919 or VIDEO_STREAM by any fh. */
1da177e4 2920 return -EBUSY;
e5bd0260 2921 }
1da177e4
LT		 2922 retval = videobuf_read_one(&fh->cap, data, count, ppos,
2923 file->f_flags & O_NONBLOCK);
8822f0d6 2924 free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ);
1da177e4
LT		 2925 break;
2926 case V4L2_BUF_TYPE_VBI_CAPTURE:
8822f0d6 2927 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
1da177e4
LT		 2928 return -EBUSY;
2929 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2930 file->f_flags & O_NONBLOCK);
2931 break;
2932 default:
2933 BUG();
2934 }
2935 return retval;
2936}
2937
2938static unsigned int bttv_poll(struct file *file, poll_table *wait)
2939{
2940 struct bttv_fh *fh = file->private_data;
2941 struct bttv_buffer *buf;
2942 enum v4l2_field field;
ae50f0f8
HV		 2943 unsigned int rc = 0;
2944 unsigned long req_events = poll_requested_events(wait);
2945
2946 if (v4l2_event_pending(&fh->fh))
2947 rc = POLLPRI;
2948 else if (req_events & POLLPRI)
2949 poll_wait(file, &fh->fh.wait, wait);
2950
2951 if (!(req_events & (POLLIN | POLLRDNORM)))
2952 return rc;
1da177e4
LT		 2953
2954 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
8822f0d6 2955 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
ae50f0f8
HV		 2956 return rc | POLLERR;
2957 return rc | videobuf_poll_stream(file, &fh->vbi, wait);
1da177e4
LT		 2958 }
2959
e5bd0260 2960 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
1da177e4
LT		 2961 /* streaming capture */
2962 if (list_empty(&fh->cap.stream))
ae50f0f8 2963 return rc | POLLERR;
1da177e4
LT		 2964 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
2965 } else {
2966 /* read() capture */
1da177e4
LT		 2967 if (NULL == fh->cap.read_buf) {
2968 /* need to capture a new frame */
64f9477f 2969 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
ae50f0f8 2970 return rc | POLLERR;
0705135e 2971 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
64f9477f 2972 if (NULL == fh->cap.read_buf)
ae50f0f8 2973 return rc | POLLERR;
1da177e4
LT		 2974 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
2975 field = videobuf_next_field(&fh->cap);
2976 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
50ab5edc
NS		 2977 kfree (fh->cap.read_buf);
2978 fh->cap.read_buf = NULL;
ae50f0f8 2979 return rc | POLLERR;
1da177e4
LT		 2980 }
2981 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
2982 fh->cap.read_off = 0;
2983 }
1da177e4
LT		 2984 buf = (struct bttv_buffer*)fh->cap.read_buf;
2985 }
2986
2987 poll_wait(file, &buf->vb.done, wait);
0fc0686e
BP		 2988 if (buf->vb.state == VIDEOBUF_DONE ||
2989 buf->vb.state == VIDEOBUF_ERROR)
ae50f0f8 2990 rc = rc | POLLIN|POLLRDNORM;
9fd6418a 2991 return rc;
1da177e4
LT		 2992}
2993
bec43661 2994static int bttv_open(struct file *file)
1da177e4 2995{
50462eb0 2996 struct video_device *vdev = video_devdata(file);
4b10d3b6 2997 struct bttv *btv = video_drvdata(file);
1da177e4
LT		 2998 struct bttv_fh *fh;
2999 enum v4l2_buf_type type = 0;
1da177e4 3000
8af443e5 3001 dprintk("open dev=%s\n", video_device_node_name(vdev));
1da177e4 3002
327ae597 3003 if (vdev->vfl_type == VFL_TYPE_GRABBER) {
4b10d3b6 3004 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
327ae597 3005 } else if (vdev->vfl_type == VFL_TYPE_VBI) {
4b10d3b6
TP		 3006 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3007 } else {
3008 WARN_ON(1);
1da177e4 3009 return -ENODEV;
d56dc612 3010 }
1da177e4 3011
8af443e5
JP		 3012 dprintk("%d: open called (type=%s)\n",
3013 btv->c.nr, v4l2_type_names[type]);
1da177e4
LT		 3014
3015 /* allocate per filehandle data */
c37db91f
MCC		 3016 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3017 if (unlikely(!fh))
1da177e4 3018 return -ENOMEM;
01df530c 3019 btv->users++;
1da177e4 3020 file->private_data = fh;
c37db91f 3021
1da177e4 3022 *fh = btv->init;
ae50f0f8 3023 v4l2_fh_init(&fh->fh, vdev);
c37db91f 3024
1da177e4
LT		 3025 fh->type = type;
3026 fh->ov.setup_ok = 0;
c37db91f 3027
0705135e
GL		 3028 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3029 &btv->c.pci->dev, &btv->s_lock,
1da177e4
LT		 3030 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3031 V4L2_FIELD_INTERLACED,
3032 sizeof(struct bttv_buffer),
587f0d5d 3033 fh, &btv->lock);
0705135e
GL		 3034 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3035 &btv->c.pci->dev, &btv->s_lock,
1da177e4
LT		 3036 V4L2_BUF_TYPE_VBI_CAPTURE,
3037 V4L2_FIELD_SEQ_TB,
3038 sizeof(struct bttv_buffer),
587f0d5d 3039 fh, &btv->lock);
302f61ad 3040 set_tvnorm(btv,btv->tvnorm);
b46a9c8b 3041 set_input(btv, btv->input, btv->tvnorm);
0757f5c5 3042 audio_mute(btv, btv->mute);
e5bd0260
MS		 3043
3044 /* The V4L2 spec requires one global set of cropping parameters
3045 which only change on request. These are stored in btv->crop[1].
3046 However for compatibility with V4L apps and cropping unaware
3047 V4L2 apps we now reset the cropping parameters as seen through
3048 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3049 will use btv->crop[0], the default cropping parameters for the
3050 current video standard, and VIDIOC_S_FMT will not implicitely
3051 change the cropping parameters until VIDIOC_S_CROP has been
3052 called. */
3053 fh->do_crop = !reset_crop; /* module parameter */
3054
3055 /* Likewise there should be one global set of VBI capture
3056 parameters, but for compatibility with V4L apps and earlier
3057 driver versions each fh has its own parameters. */
3058 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3059
1da177e4 3060 bttv_field_count(btv);
ae50f0f8 3061 v4l2_fh_add(&fh->fh);
1da177e4
LT		 3062 return 0;
3063}
3064
bec43661 3065static int bttv_release(struct file *file)
1da177e4
LT		 3066{
3067 struct bttv_fh *fh = file->private_data;
3068 struct bttv *btv = fh->btv;
3069
3070 /* turn off overlay */
3071 if (check_btres(fh, RESOURCE_OVERLAY))
3072 bttv_switch_overlay(btv,fh,NULL);
3073
3074 /* stop video capture */
e5bd0260 3075 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
1da177e4 3076 videobuf_streamoff(&fh->cap);
8822f0d6 3077 free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM);
1da177e4
LT		 3078 }
3079 if (fh->cap.read_buf) {
3080 buffer_release(&fh->cap,fh->cap.read_buf);
3081 kfree(fh->cap.read_buf);
3082 }
e5bd0260 3083 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
8822f0d6 3084 free_btres_lock(btv, fh, RESOURCE_VIDEO_READ);
e5bd0260 3085 }
1da177e4
LT		 3086
3087 /* stop vbi capture */
3088 if (check_btres(fh, RESOURCE_VBI)) {
053fcb60 3089 videobuf_stop(&fh->vbi);
8822f0d6 3090 free_btres_lock(btv,fh,RESOURCE_VBI);
1da177e4
LT		 3091 }
3092
3093 /* free stuff */
c37db91f 3094
1da177e4
LT		 3095 videobuf_mmap_free(&fh->cap);
3096 videobuf_mmap_free(&fh->vbi);
1da177e4 3097 file->private_data = NULL;
1da177e4
LT		 3098
3099 btv->users--;
3100 bttv_field_count(btv);
b46a9c8b
MCC		 3101
3102 if (!btv->users)
01df530c 3103 audio_mute(btv, btv->mute);
b46a9c8b 3104
ae50f0f8
HV		 3105 v4l2_fh_del(&fh->fh);
3106 v4l2_fh_exit(&fh->fh);
3107 kfree(fh);
1da177e4
LT		 3108 return 0;
3109}
3110
3111static int
3112bttv_mmap(struct file *file, struct vm_area_struct *vma)
3113{
3114 struct bttv_fh *fh = file->private_data;
3115
8af443e5 3116 dprintk("%d: mmap type=%s 0x%lx+%ld\n",
1da177e4
LT		 3117 fh->btv->c.nr, v4l2_type_names[fh->type],
3118 vma->vm_start, vma->vm_end - vma->vm_start);
3119 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3120}
3121
bec43661 3122static const struct v4l2_file_operations bttv_fops =
1da177e4 3123{
8979e9d4
MCC		 3124 .owner = THIS_MODULE,
3125 .open = bttv_open,
3126 .release = bttv_release,
3127 .unlocked_ioctl = video_ioctl2,
3128 .read = bttv_read,
3129 .mmap = bttv_mmap,
3130 .poll = bttv_poll,
1da177e4
LT		 3131};
3132
a399810c 3133static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
e5ae3db4 3134 .vidioc_querycap = bttv_querycap,
78b526a4
HV		 3135 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
3136 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
3137 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
3138 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
3139 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay,
3140 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay,
3141 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay,
3142 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay,
78b526a4
HV		 3143 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
3144 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
3145 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
e5ae3db4
MCC		 3146 .vidioc_cropcap = bttv_cropcap,
3147 .vidioc_reqbufs = bttv_reqbufs,
3148 .vidioc_querybuf = bttv_querybuf,
3149 .vidioc_qbuf = bttv_qbuf,
3150 .vidioc_dqbuf = bttv_dqbuf,
3151 .vidioc_s_std = bttv_s_std,
6795cc55 3152 .vidioc_g_std = bttv_g_std,
e5ae3db4
MCC		 3153 .vidioc_enum_input = bttv_enum_input,
3154 .vidioc_g_input = bttv_g_input,
3155 .vidioc_s_input = bttv_s_input,
e5ae3db4
MCC		 3156 .vidioc_streamon = bttv_streamon,
3157 .vidioc_streamoff = bttv_streamoff,
3158 .vidioc_g_tuner = bttv_g_tuner,
3159 .vidioc_s_tuner = bttv_s_tuner,
e5ae3db4
MCC		 3160 .vidioc_g_crop = bttv_g_crop,
3161 .vidioc_s_crop = bttv_s_crop,
3162 .vidioc_g_fbuf = bttv_g_fbuf,
3163 .vidioc_s_fbuf = bttv_s_fbuf,
3164 .vidioc_overlay = bttv_overlay,
e5ae3db4
MCC		 3165 .vidioc_g_parm = bttv_g_parm,
3166 .vidioc_g_frequency = bttv_g_frequency,
3167 .vidioc_s_frequency = bttv_s_frequency,
3168 .vidioc_log_status = bttv_log_status,
3169 .vidioc_querystd = bttv_querystd,
ae50f0f8
HV		 3170 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
3171 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
43846835 3172#ifdef CONFIG_VIDEO_ADV_DEBUG
e5ae3db4
MCC		 3173 .vidioc_g_register = bttv_g_register,
3174 .vidioc_s_register = bttv_s_register,
43846835 3175#endif
a399810c
HV		 3176};
3177
3178static struct video_device bttv_video_template = {
3179 .fops = &bttv_fops,
a399810c
HV		 3180 .ioctl_ops = &bttv_ioctl_ops,
3181 .tvnorms = BTTV_NORMS,
1da177e4
LT		 3182};
3183
1da177e4
LT		 3184/* ----------------------------------------------------------------------- */
3185/* radio interface */
3186
bec43661 3187static int radio_open(struct file *file)
1da177e4 3188{
50462eb0 3189 struct video_device *vdev = video_devdata(file);
4b10d3b6 3190 struct bttv *btv = video_drvdata(file);
5cd3955c 3191 struct bttv_fh *fh;
1da177e4 3192
8af443e5 3193 dprintk("open dev=%s\n", video_device_node_name(vdev));
1da177e4 3194
8af443e5 3195 dprintk("%d: open called (radio)\n", btv->c.nr);
5cd3955c
RF		 3196
3197 /* allocate per filehandle data */
3198 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
c37db91f 3199 if (unlikely(!fh))
5cd3955c
RF		 3200 return -ENOMEM;
3201 file->private_data = fh;
3202 *fh = btv->init;
8c14cc1f 3203 v4l2_fh_init(&fh->fh, vdev);
24a70fdc 3204
1da177e4 3205 btv->radio_user++;
0757f5c5 3206 audio_mute(btv, btv->mute);
24a70fdc 3207
8c14cc1f 3208 v4l2_fh_add(&fh->fh);
1da177e4 3209
4ac97914 3210 return 0;
1da177e4
LT		 3211}
3212
bec43661 3213static int radio_release(struct file *file)
1da177e4 3214{
5cd3955c
RF		 3215 struct bttv_fh *fh = file->private_data;
3216 struct bttv *btv = fh->btv;
b9218f2f 3217 struct saa6588_command cmd;
1da177e4 3218
b9bc07a0 3219 file->private_data = NULL;
8c14cc1f
HV		 3220 v4l2_fh_del(&fh->fh);
3221 v4l2_fh_exit(&fh->fh);
b9bc07a0
RF		 3222 kfree(fh);
3223
1da177e4 3224 btv->radio_user--;
24a70fdc 3225
b9218f2f 3226 bttv_call_all(btv, core, ioctl, SAA6588_CMD_CLOSE, &cmd);
24a70fdc 3227
b8e2a361
HV		 3228 if (btv->radio_user == 0)
3229 btv->has_radio_tuner = 0;
1da177e4
LT		 3230 return 0;
3231}
3232
402aa76a
DSL		 3233static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3234{
3235 struct bttv_fh *fh = priv;
3236 struct bttv *btv = fh->btv;
e84619b1 3237
402aa76a
DSL		 3238 if (0 != t->index)
3239 return -EINVAL;
402aa76a
DSL		 3240 strcpy(t->name, "Radio");
3241 t->type = V4L2_TUNER_RADIO;
b8e2a361 3242 radio_enable(btv);
4b9b936f 3243
859f0277 3244 bttv_call_all(btv, tuner, g_tuner, t);
402aa76a
DSL		 3245
3246 if (btv->audio_mode_gpio)
3247 btv->audio_mode_gpio(btv, t, 0);
3248
35655bf8
OZ		 3249 if (btv->has_tea575x)
3250 return snd_tea575x_g_tuner(&btv->tea, t);
3251
402aa76a
DSL		 3252 return 0;
3253}
3254
402aa76a 3255static int radio_s_tuner(struct file *file, void *priv,
2f73c7c5 3256 const struct v4l2_tuner *t)
402aa76a
DSL		 3257{
3258 struct bttv_fh *fh = priv;
3259 struct bttv *btv = fh->btv;
3260
3261 if (0 != t->index)
3262 return -EINVAL;
3263
b8e2a361 3264 radio_enable(btv);
a024c1a6 3265 bttv_call_all(btv, tuner, s_tuner, t);
402aa76a
DSL		 3266 return 0;
3267}
3268
35655bf8
OZ		 3269static int radio_s_hw_freq_seek(struct file *file, void *priv,
3270 const struct v4l2_hw_freq_seek *a)
3271{
3272 struct bttv_fh *fh = priv;
3273 struct bttv *btv = fh->btv;
3274
3275 if (btv->has_tea575x)
3276 return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a);
3277
3278 return -ENOTTY;
3279}
3280
3281static int radio_enum_freq_bands(struct file *file, void *priv,
3282 struct v4l2_frequency_band *band)
3283{
3284 struct bttv_fh *fh = priv;
3285 struct bttv *btv = fh->btv;
3286
3287 if (btv->has_tea575x)
3288 return snd_tea575x_enum_freq_bands(&btv->tea, band);
3289
3290 return -ENOTTY;
3291}
3292
24a70fdc
MCC		 3293static ssize_t radio_read(struct file *file, char __user *data,
3294 size_t count, loff_t *ppos)
3295{
5cd3955c
RF		 3296 struct bttv_fh *fh = file->private_data;
3297 struct bttv *btv = fh->btv;
b9218f2f 3298 struct saa6588_command cmd;
09092787
HV		 3299
3300 cmd.block_count = count / 3;
3301 cmd.nonblocking = file->f_flags & O_NONBLOCK;
24a70fdc
MCC		 3302 cmd.buffer = data;
3303 cmd.instance = file;
3304 cmd.result = -ENODEV;
b8e2a361 3305 radio_enable(btv);
24a70fdc 3306
b9218f2f 3307 bttv_call_all(btv, core, ioctl, SAA6588_CMD_READ, &cmd);
24a70fdc
MCC		 3308
3309 return cmd.result;
3310}
3311
3312static unsigned int radio_poll(struct file *file, poll_table *wait)
3313{
5cd3955c
RF		 3314 struct bttv_fh *fh = file->private_data;
3315 struct bttv *btv = fh->btv;
ae50f0f8 3316 unsigned long req_events = poll_requested_events(wait);
b9218f2f 3317 struct saa6588_command cmd;
ae50f0f8
HV		 3318 unsigned int res = 0;
3319
3320 if (v4l2_event_pending(&fh->fh))
3321 res = POLLPRI;
3322 else if (req_events & POLLPRI)
3323 poll_wait(file, &fh->fh.wait, wait);
b8e2a361 3324 radio_enable(btv);
24a70fdc
MCC		 3325 cmd.instance = file;
3326 cmd.event_list = wait;
ae50f0f8 3327 cmd.result = res;
b9218f2f 3328 bttv_call_all(btv, core, ioctl, SAA6588_CMD_POLL, &cmd);
24a70fdc
MCC		 3329
3330 return cmd.result;
3331}
3332
bec43661 3333static const struct v4l2_file_operations radio_fops =
1da177e4
LT		 3334{
3335 .owner = THIS_MODULE,
3336 .open = radio_open,
24a70fdc 3337 .read = radio_read,
1da177e4 3338 .release = radio_release,
587f0d5d 3339 .unlocked_ioctl = video_ioctl2,
24a70fdc 3340 .poll = radio_poll,
1da177e4
LT		 3341};
3342
a399810c 3343static const struct v4l2_ioctl_ops radio_ioctl_ops = {
78dea1ae 3344 .vidioc_querycap = bttv_querycap,
01df530c 3345 .vidioc_log_status = bttv_log_status,
402aa76a 3346 .vidioc_g_tuner = radio_g_tuner,
402aa76a 3347 .vidioc_s_tuner = radio_s_tuner,
e5ae3db4
MCC		 3348 .vidioc_g_frequency = bttv_g_frequency,
3349 .vidioc_s_frequency = bttv_s_frequency,
35655bf8
OZ		 3350 .vidioc_s_hw_freq_seek = radio_s_hw_freq_seek,
3351 .vidioc_enum_freq_bands = radio_enum_freq_bands,
ae50f0f8
HV		 3352 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
3353 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1da177e4
LT		 3354};
3355
a399810c
HV		 3356static struct video_device radio_template = {
3357 .fops = &radio_fops,
a399810c
HV		 3358 .ioctl_ops = &radio_ioctl_ops,
3359};
3360
1da177e4
LT		 3361/* ----------------------------------------------------------------------- */
3362/* some debug code */
3363
408b664a 3364static int bttv_risc_decode(u32 risc)
1da177e4
LT		 3365{
3366 static char *instr[16] = {
3367 [ BT848_RISC_WRITE >> 28 ] = "write",
3368 [ BT848_RISC_SKIP >> 28 ] = "skip",
3369 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3370 [ BT848_RISC_JUMP >> 28 ] = "jump",
3371 [ BT848_RISC_SYNC >> 28 ] = "sync",
3372 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3373 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3374 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3375 };
3376 static int incr[16] = {
3377 [ BT848_RISC_WRITE >> 28 ] = 2,
3378 [ BT848_RISC_JUMP >> 28 ] = 2,
3379 [ BT848_RISC_SYNC >> 28 ] = 2,
3380 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3381 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3382 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3383 };
3384 static char *bits[] = {
3385 "be0", "be1", "be2", "be3/resync",
3386 "set0", "set1", "set2", "set3",
3387 "clr0", "clr1", "clr2", "clr3",
3388 "irq", "res", "eol", "sol",
3389 };
3390 int i;
3391
8af443e5 3392 pr_cont("0x%08x [ %s", risc,
1da177e4
LT		 3393 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3394 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3395 if (risc & (1 << (i + 12)))
8af443e5
JP		 3396 pr_cont(" %s", bits[i]);
3397 pr_cont(" count=%d ]\n", risc & 0xfff);
1da177e4
LT		 3398 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3399}
3400
408b664a
AB		 3401static void bttv_risc_disasm(struct bttv *btv,
3402 struct btcx_riscmem *risc)
1da177e4
LT		 3403{
3404 unsigned int i,j,n;
3405
8af443e5
JP		 3406 pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
3407 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
1da177e4 3408 for (i = 0; i < (risc->size >> 2); i += n) {
8af443e5
JP		 3409 pr_info("%s: 0x%lx: ",
3410 btv->c.v4l2_dev.name,
3411 (unsigned long)(risc->dma + (i<<2)));
3aa7110e 3412 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
1da177e4 3413 for (j = 1; j < n; j++)
8af443e5
JP		 3414 pr_info("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3415 btv->c.v4l2_dev.name,
3416 (unsigned long)(risc->dma + ((i+j)<<2)),
3417 risc->cpu[i+j], j);
1da177e4
LT		 3418 if (0 == risc->cpu[i])
3419 break;
3420 }
3421}
3422
3423static void bttv_print_riscaddr(struct bttv *btv)
3424{
8af443e5
JP		 3425 pr_info(" main: %08llx\n", (unsigned long long)btv->main.dma);
3426 pr_info(" vbi : o=%08llx e=%08llx\n",
3427 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3428 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3429 pr_info(" cap : o=%08llx e=%08llx\n",
3430 btv->curr.top
3431 ? (unsigned long long)btv->curr.top->top.dma : 0,
3432 btv->curr.bottom
3433 ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3434 pr_info(" scr : o=%08llx e=%08llx\n",
3435 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3436 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
1da177e4
LT		 3437 bttv_risc_disasm(btv, &btv->main);
3438}
3439
3440/* ----------------------------------------------------------------------- */
3441/* irq handler */
3442
3443static char *irq_name[] = {
3444 "FMTCHG", // format change detected (525 vs. 625)
3445 "VSYNC", // vertical sync (new field)
3446 "HSYNC", // horizontal sync
3447 "OFLOW", // chroma/luma AGC overflow
3448 "HLOCK", // horizontal lock changed
3449 "VPRES", // video presence changed
3450 "6", "7",
3451 "I2CDONE", // hw irc operation finished
3452 "GPINT", // gpio port triggered irq
3453 "10",
3454 "RISCI", // risc instruction triggered irq
3455 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3456 "FTRGT", // pixel data fifo overrun
3457 "FDSR", // fifo data stream resyncronisation
3458 "PPERR", // parity error (data transfer)
3459 "RIPERR", // parity error (read risc instructions)
3460 "PABORT", // pci abort
3461 "OCERR", // risc instruction error
3462 "SCERR", // syncronisation error
3463};
3464
3465static void bttv_print_irqbits(u32 print, u32 mark)
3466{
3467 unsigned int i;
3468
8af443e5 3469 pr_cont("bits:");
1da177e4
LT		 3470 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3471 if (print & (1 << i))
8af443e5 3472 pr_cont(" %s", irq_name[i]);
1da177e4 3473 if (mark & (1 << i))
8af443e5 3474 pr_cont("*");
1da177e4
LT		 3475 }
3476}
3477
3478static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3479{
8af443e5
JP		 3480 pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3481 btv->c.nr,
3482 (unsigned long)btv->main.dma,
3483 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3484 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3485 (unsigned long)rc);
1da177e4
LT		 3486
3487 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
8af443e5
JP		 3488 pr_notice("%d: Oh, there (temporarily?) is no input signal. "
3489 "Ok, then this is harmless, don't worry ;)\n",
3490 btv->c.nr);
1da177e4
LT		 3491 return;
3492 }
8af443e5
JP		 3493 pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n",
3494 btv->c.nr);
3495 pr_notice("%d: Lets try to catch the culpit red-handed ...\n",
3496 btv->c.nr);
1da177e4
LT		 3497 dump_stack();
3498}
3499
3500static int
3501bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3502{
3503 struct bttv_buffer *item;
3504
3505 memset(set,0,sizeof(*set));
3506
3507 /* capture request ? */
3508 if (!list_empty(&btv->capture)) {
3509 set->frame_irq = 1;
3510 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3511 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3512 set->top = item;
3513 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3514 set->bottom = item;
3515
3516 /* capture request for other field ? */
3517 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3518 (item->vb.queue.next != &btv->capture)) {
3519 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
66349b4e
MI		 3520 /* Mike Isely <isely@pobox.com> - Only check
3521 * and set up the bottom field in the logic
3522 * below. Don't ever do the top field. This
3523 * of course means that if we set up the
3524 * bottom field in the above code that we'll
3525 * actually skip a field. But that's OK.
3526 * Having processed only a single buffer this
3527 * time, then the next time around the first
3528 * available buffer should be for a top field.
3529 * That will then cause us here to set up a
3530 * top then a bottom field in the normal way.
3531 * The alternative to this understanding is
3532 * that we set up the second available buffer
3533 * as a top field, but that's out of order
3534 * since this driver always processes the top
3535 * field first - the effect will be the two
3536 * buffers being returned in the wrong order,
3537 * with the second buffer also being delayed
3538 * by one field time (owing to the fifo nature
3539 * of videobuf). Worse still, we'll be stuck
3540 * doing fields out of order now every time
3541 * until something else causes a field to be
3542 * dropped. By effectively forcing a field to
3543 * drop this way then we always get back into
3544 * sync within a single frame time. (Out of
3545 * order fields can screw up deinterlacing
3546 * algorithms.) */
1da177e4 3547 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
1da177e4
LT		 3548 if (NULL == set->bottom &&
3549 V4L2_FIELD_BOTTOM == item->vb.field) {
3550 set->bottom = item;
3551 }
3552 if (NULL != set->top && NULL != set->bottom)
3553 set->top_irq = 2;
3554 }
3555 }
3556 }
3557
3558 /* screen overlay ? */
3559 if (NULL != btv->screen) {
3560 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3561 if (NULL == set->top && NULL == set->bottom) {
3562 set->top = btv->screen;
3563 set->bottom = btv->screen;
3564 }
3565 } else {
3566 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3567 NULL == set->top) {
3568 set->top = btv->screen;
3569 }
3570 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3571 NULL == set->bottom) {
3572 set->bottom = btv->screen;
3573 }
3574 }
3575 }
3576
8af443e5
JP		 3577 dprintk("%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3578 btv->c.nr, set->top, set->bottom,
3579 btv->screen, set->frame_irq, set->top_irq);
1da177e4
LT		 3580 return 0;
3581}
3582
3583static void
3584bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3585 struct bttv_buffer_set *curr, unsigned int state)
3586{
3587 struct timeval ts;
3588
8e6057b5 3589 v4l2_get_timestamp(&ts);
1da177e4
LT		 3590
3591 if (wakeup->top == wakeup->bottom) {
3592 if (NULL != wakeup->top && curr->top != wakeup->top) {
3593 if (irq_debug > 1)
8af443e5
JP		 3594 pr_debug("%d: wakeup: both=%p\n",
3595 btv->c.nr, wakeup->top);
1da177e4
LT		 3596 wakeup->top->vb.ts = ts;
3597 wakeup->top->vb.field_count = btv->field_count;
3598 wakeup->top->vb.state = state;
3599 wake_up(&wakeup->top->vb.done);
3600 }
3601 } else {
3602 if (NULL != wakeup->top && curr->top != wakeup->top) {
3603 if (irq_debug > 1)
8af443e5
JP		 3604 pr_debug("%d: wakeup: top=%p\n",
3605 btv->c.nr, wakeup->top);
1da177e4
LT		 3606 wakeup->top->vb.ts = ts;
3607 wakeup->top->vb.field_count = btv->field_count;
3608 wakeup->top->vb.state = state;
3609 wake_up(&wakeup->top->vb.done);
3610 }
3611 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3612 if (irq_debug > 1)
8af443e5
JP		 3613 pr_debug("%d: wakeup: bottom=%p\n",
3614 btv->c.nr, wakeup->bottom);
1da177e4
LT		 3615 wakeup->bottom->vb.ts = ts;
3616 wakeup->bottom->vb.field_count = btv->field_count;
3617 wakeup->bottom->vb.state = state;
3618 wake_up(&wakeup->bottom->vb.done);
3619 }
3620 }
3621}
3622
3623static void
3624bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3625 unsigned int state)
3626{
3627 struct timeval ts;
3628
3629 if (NULL == wakeup)
3630 return;
3631
8e6057b5 3632 v4l2_get_timestamp(&ts);
1da177e4
LT		 3633 wakeup->vb.ts = ts;
3634 wakeup->vb.field_count = btv->field_count;
3635 wakeup->vb.state = state;
3636 wake_up(&wakeup->vb.done);
3637}
3638
3639static void bttv_irq_timeout(unsigned long data)
3640{
3641 struct bttv *btv = (struct bttv *)data;
3642 struct bttv_buffer_set old,new;
3643 struct bttv_buffer *ovbi;
3644 struct bttv_buffer *item;
3645 unsigned long flags;
3646
3647 if (bttv_verbose) {
8af443e5
JP		 3648 pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3649 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3650 btread(BT848_RISC_COUNT));
1da177e4 3651 bttv_print_irqbits(btread(BT848_INT_STAT),0);
8af443e5 3652 pr_cont("\n");
1da177e4
LT		 3653 }
3654
3655 spin_lock_irqsave(&btv->s_lock,flags);
3656
3657 /* deactivate stuff */
3658 memset(&new,0,sizeof(new));
3659 old = btv->curr;
3660 ovbi = btv->cvbi;
3661 btv->curr = new;
3662 btv->cvbi = NULL;
3663 btv->loop_irq = 0;
3664 bttv_buffer_activate_video(btv, &new);
3665 bttv_buffer_activate_vbi(btv, NULL);
3666 bttv_set_dma(btv, 0);
3667
3668 /* wake up */
0fc0686e
BP		 3669 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3670 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
1da177e4
LT		 3671
3672 /* cancel all outstanding capture / vbi requests */
3673 while (!list_empty(&btv->capture)) {
3674 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3675 list_del(&item->vb.queue);
0fc0686e 3676 item->vb.state = VIDEOBUF_ERROR;
1da177e4
LT		 3677 wake_up(&item->vb.done);
3678 }
3679 while (!list_empty(&btv->vcapture)) {
3680 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3681 list_del(&item->vb.queue);
0fc0686e 3682 item->vb.state = VIDEOBUF_ERROR;
1da177e4
LT		 3683 wake_up(&item->vb.done);
3684 }
3685
3686 btv->errors++;
3687 spin_unlock_irqrestore(&btv->s_lock,flags);
3688}
3689
3690static void
3691bttv_irq_wakeup_top(struct bttv *btv)
3692{
3693 struct bttv_buffer *wakeup = btv->curr.top;
3694
3695 if (NULL == wakeup)
3696 return;
3697
3698 spin_lock(&btv->s_lock);
3699 btv->curr.top_irq = 0;
3700 btv->curr.top = NULL;
3701 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3702
8e6057b5 3703 v4l2_get_timestamp(&wakeup->vb.ts);
1da177e4 3704 wakeup->vb.field_count = btv->field_count;
0fc0686e 3705 wakeup->vb.state = VIDEOBUF_DONE;
1da177e4
LT		 3706 wake_up(&wakeup->vb.done);
3707 spin_unlock(&btv->s_lock);
3708}
3709
3710static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3711{
3712 if (rc < risc->dma)
3713 return 0;
3714 if (rc > risc->dma + risc->size)
3715 return 0;
3716 return 1;
3717}
3718
3719static void
3720bttv_irq_switch_video(struct bttv *btv)
3721{
3722 struct bttv_buffer_set new;
3723 struct bttv_buffer_set old;
3724 dma_addr_t rc;
3725
3726 spin_lock(&btv->s_lock);
3727
3728 /* new buffer set */
3729 bttv_irq_next_video(btv, &new);
3730 rc = btread(BT848_RISC_COUNT);
3731 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3732 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3733 btv->framedrop++;
3734 if (debug_latency)
3735 bttv_irq_debug_low_latency(btv, rc);
3736 spin_unlock(&btv->s_lock);
3737 return;
3738 }
3739
3740 /* switch over */
3741 old = btv->curr;
3742 btv->curr = new;
3743 btv->loop_irq &= ~1;
3744 bttv_buffer_activate_video(btv, &new);
3745 bttv_set_dma(btv, 0);
3746
3747 /* switch input */
3748 if (UNSET != btv->new_input) {
3749 video_mux(btv,btv->new_input);
3750 btv->new_input = UNSET;
3751 }
3752
3753 /* wake up finished buffers */
0fc0686e 3754 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
1da177e4
LT		 3755 spin_unlock(&btv->s_lock);
3756}
3757
3758static void
3759bttv_irq_switch_vbi(struct bttv *btv)
3760{
3761 struct bttv_buffer *new = NULL;
3762 struct bttv_buffer *old;
3763 u32 rc;
3764
3765 spin_lock(&btv->s_lock);
3766
3767 if (!list_empty(&btv->vcapture))
3768 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3769 old = btv->cvbi;
3770
3771 rc = btread(BT848_RISC_COUNT);
3772 if (NULL != old && (is_active(&old->top, rc) ||
3773 is_active(&old->bottom, rc))) {
3774 btv->framedrop++;
3775 if (debug_latency)
3776 bttv_irq_debug_low_latency(btv, rc);
3777 spin_unlock(&btv->s_lock);
3778 return;
3779 }
3780
3781 /* switch */
3782 btv->cvbi = new;
3783 btv->loop_irq &= ~4;
3784 bttv_buffer_activate_vbi(btv, new);
3785 bttv_set_dma(btv, 0);
3786
0fc0686e 3787 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
1da177e4
LT		 3788 spin_unlock(&btv->s_lock);
3789}
3790
7d12e780 3791static irqreturn_t bttv_irq(int irq, void *dev_id)
1da177e4
LT		 3792{
3793 u32 stat,astat;
3794 u32 dstat;
3795 int count;
3796 struct bttv *btv;
3797 int handled = 0;
3798
3799 btv=(struct bttv *)dev_id;
6c6c0b2c 3800
1da177e4
LT		 3801 count=0;
3802 while (1) {
3803 /* get/clear interrupt status bits */
3804 stat=btread(BT848_INT_STAT);
3805 astat=stat&btread(BT848_INT_MASK);
3806 if (!astat)
3807 break;
3808 handled = 1;
3809 btwrite(stat,BT848_INT_STAT);
3810
3811 /* get device status bits */
3812 dstat=btread(BT848_DSTATUS);
3813
3814 if (irq_debug) {
8af443e5
JP		 3815 pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ",
3816 btv->c.nr, count, btv->field_count,
3817 stat>>28, btread(BT848_RISC_COUNT));
1da177e4
LT		 3818 bttv_print_irqbits(stat,astat);
3819 if (stat & BT848_INT_HLOCK)
8af443e5
JP		 3820 pr_cont(" HLOC => %s",
3821 dstat & BT848_DSTATUS_HLOC
3822 ? "yes" : "no");
1da177e4 3823 if (stat & BT848_INT_VPRES)
8af443e5
JP		 3824 pr_cont(" PRES => %s",
3825 dstat & BT848_DSTATUS_PRES
3826 ? "yes" : "no");
1da177e4 3827 if (stat & BT848_INT_FMTCHG)
8af443e5
JP		 3828 pr_cont(" NUML => %s",
3829 dstat & BT848_DSTATUS_NUML
3830 ? "625" : "525");
3831 pr_cont("\n");
1da177e4
LT		 3832 }
3833
3834 if (astat&BT848_INT_VSYNC)
4ac97914 3835 btv->field_count++;
1da177e4 3836
4abdfed5 3837 if ((astat & BT848_INT_GPINT) && btv->remote) {
4abdfed5 3838 bttv_input_irq(btv);
1da177e4
LT		 3839 }
3840
3841 if (astat & BT848_INT_I2CDONE) {
3842 btv->i2c_done = stat;
3843 wake_up(&btv->i2c_queue);
3844 }
3845
4ac97914 3846 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
1da177e4
LT		 3847 bttv_irq_switch_vbi(btv);
3848
4ac97914 3849 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
1da177e4
LT		 3850 bttv_irq_wakeup_top(btv);
3851
4ac97914 3852 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
1da177e4
LT		 3853 bttv_irq_switch_video(btv);
3854
3855 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
5f456781
FS		 3856 /* trigger automute */
3857 audio_mux_gpio(btv, btv->audio_input, btv->mute);
1da177e4
LT		 3858
3859 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
8af443e5
JP		 3860 pr_info("%d: %s%s @ %08x,",
3861 btv->c.nr,
3862 (astat & BT848_INT_SCERR) ? "SCERR" : "",
3863 (astat & BT848_INT_OCERR) ? "OCERR" : "",
3864 btread(BT848_RISC_COUNT));
1da177e4 3865 bttv_print_irqbits(stat,astat);
8af443e5 3866 pr_cont("\n");
1da177e4
LT		 3867 if (bttv_debug)
3868 bttv_print_riscaddr(btv);
3869 }
3870 if (fdsr && astat & BT848_INT_FDSR) {
8af443e5
JP		 3871 pr_info("%d: FDSR @ %08x\n",
3872 btv->c.nr, btread(BT848_RISC_COUNT));
1da177e4
LT		 3873 if (bttv_debug)
3874 bttv_print_riscaddr(btv);
3875 }
3876
3877 count++;
3878 if (count > 4) {
c58c21c7 3879
3880 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4ac97914 3881 btwrite(0, BT848_INT_MASK);
c58c21c7 3882
8af443e5
JP		 3883 pr_err("%d: IRQ lockup, cleared int mask [",
3884 btv->c.nr);
c58c21c7 3885 } else {
8af443e5
JP		 3886 pr_err("%d: IRQ lockup, clearing GPINT from int mask [",
3887 btv->c.nr);
c58c21c7 3888
3889 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3890 BT848_INT_MASK);
c3142a61 3891 }
c58c21c7 3892
1da177e4 3893 bttv_print_irqbits(stat,astat);
c58c21c7 3894
8af443e5 3895 pr_cont("]\n");
1da177e4
LT		 3896 }
3897 }
3898 btv->irq_total++;
3899 if (handled)
3900 btv->irq_me++;
3901 return IRQ_RETVAL(handled);
3902}
3903
3904
3905/* ----------------------------------------------------------------------- */
d9b67076 3906/* initialization */
1da177e4 3907
23fb4c5e
HV		 3908static void vdev_init(struct bttv *btv,
3909 struct video_device *vfd,
3910 const struct video_device *template,
3911 const char *type_name)
1da177e4 3912{
1da177e4 3913 *vfd = *template;
74fc7bd9 3914 vfd->v4l2_dev = &btv->c.v4l2_dev;
23fb4c5e 3915 vfd->release = video_device_release_empty;
4b10d3b6 3916 video_set_drvdata(vfd, btv);
1da177e4
LT		 3917 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3918 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
9134be03 3919 type_name, bttv_tvcards[btv->c.type].name);
d9b67076
HV		 3920 if (btv->tuner_type == TUNER_ABSENT) {
3921 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY);
3922 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY);
3923 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
3924 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
3925 }
1da177e4
LT		 3926}
3927
3928static void bttv_unregister_video(struct bttv *btv)
3929{
23fb4c5e
HV		 3930 video_unregister_device(&btv->video_dev);
3931 video_unregister_device(&btv->vbi_dev);
3932 video_unregister_device(&btv->radio_dev);
1da177e4
LT		 3933}
3934
3935/* register video4linux devices */
4c62e976 3936static int bttv_register_video(struct bttv *btv)
1da177e4 3937{
0ea6bc8d 3938 if (no_overlay > 0)
8af443e5 3939 pr_notice("Overlay support disabled\n");
4dcef524 3940
1da177e4 3941 /* video */
23fb4c5e 3942 vdev_init(btv, &btv->video_dev, &bttv_video_template, "video");
9134be03 3943
23fb4c5e 3944 if (video_register_device(&btv->video_dev, VFL_TYPE_GRABBER,
176c2f34 3945 video_nr[btv->c.nr]) < 0)
1da177e4 3946 goto err;
8af443e5 3947 pr_info("%d: registered device %s\n",
23fb4c5e
HV		 3948 btv->c.nr, video_device_node_name(&btv->video_dev));
3949 if (device_create_file(&btv->video_dev.dev,
54bd5b66 3950 &dev_attr_card)<0) {
8af443e5 3951 pr_err("%d: device_create_file 'card' failed\n", btv->c.nr);
d94fc9a0
TP		 3952 goto err;
3953 }
1da177e4
LT		 3954
3955 /* vbi */
23fb4c5e 3956 vdev_init(btv, &btv->vbi_dev, &bttv_video_template, "vbi");
9134be03 3957
23fb4c5e 3958 if (video_register_device(&btv->vbi_dev, VFL_TYPE_VBI,
176c2f34 3959 vbi_nr[btv->c.nr]) < 0)
1da177e4 3960 goto err;
8af443e5 3961 pr_info("%d: registered device %s\n",
23fb4c5e 3962 btv->c.nr, video_device_node_name(&btv->vbi_dev));
1da177e4 3963
4ac97914 3964 if (!btv->has_radio)
1da177e4
LT		 3965 return 0;
3966 /* radio */
23fb4c5e
HV		 3967 vdev_init(btv, &btv->radio_dev, &radio_template, "radio");
3968 btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler;
3969 if (video_register_device(&btv->radio_dev, VFL_TYPE_RADIO,
176c2f34 3970 radio_nr[btv->c.nr]) < 0)
1da177e4 3971 goto err;
8af443e5 3972 pr_info("%d: registered device %s\n",
23fb4c5e 3973 btv->c.nr, video_device_node_name(&btv->radio_dev));
1da177e4
LT		 3974
3975 /* all done */
3976 return 0;
3977
3978 err:
3979 bttv_unregister_video(btv);
3980 return -1;
3981}
3982
3983
3984/* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3985/* response on cards with no firmware is not enabled by OF */
3986static void pci_set_command(struct pci_dev *dev)
3987{
3988#if defined(__powerpc__)
4ac97914 3989 unsigned int cmd;
1da177e4 3990
4ac97914
MCC		 3991 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3992 cmd = (cmd | PCI_COMMAND_MEMORY );
3993 pci_write_config_dword(dev, PCI_COMMAND, cmd);
1da177e4
LT		 3994#endif
3995}
3996
4c62e976 3997static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
1da177e4 3998{
76ea992a
HV		 3999 struct v4l2_frequency init_freq = {
4000 .tuner = 0,
4001 .type = V4L2_TUNER_ANALOG_TV,
4002 .frequency = 980,
4003 };
1da177e4
LT		 4004 int result;
4005 unsigned char lat;
4006 struct bttv *btv;
01df530c 4007 struct v4l2_ctrl_handler *hdl;
1da177e4
LT		 4008
4009 if (bttv_num == BTTV_MAX)
4010 return -ENOMEM;
8af443e5 4011 pr_info("Bt8xx card found (%d)\n", bttv_num);
4b10d3b6 4012 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
74fc7bd9 4013 if (btv == NULL) {
8af443e5 4014 pr_err("out of memory\n");
74fc7bd9
HV		 4015 return -ENOMEM;
4016 }
1da177e4 4017 btv->c.nr = bttv_num;
74fc7bd9
HV		 4018 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4019 "bttv%d", btv->c.nr);
1da177e4
LT		 4020
4021 /* initialize structs / fill in defaults */
bd5f0ac9 4022 mutex_init(&btv->lock);
4ac97914
MCC		 4023 spin_lock_init(&btv->s_lock);
4024 spin_lock_init(&btv->gpio_lock);
4ac97914
MCC		 4025 init_waitqueue_head(&btv->i2c_queue);
4026 INIT_LIST_HEAD(&btv->c.subs);
4027 INIT_LIST_HEAD(&btv->capture);
4028 INIT_LIST_HEAD(&btv->vcapture);
1da177e4
LT		 4029
4030 init_timer(&btv->timeout);
4031 btv->timeout.function = bttv_irq_timeout;
4032 btv->timeout.data = (unsigned long)btv;
4033
7c08fb02
MK		 4034 btv->i2c_rc = -1;
4035 btv->tuner_type = UNSET;
1da177e4 4036 btv->new_input = UNSET;
1da177e4
LT		 4037 btv->has_radio=radio[btv->c.nr];
4038
4039 /* pci stuff (init, get irq/mmio, ... */
4040 btv->c.pci = dev;
7c08fb02 4041 btv->id = dev->device;
1da177e4 4042 if (pci_enable_device(dev)) {
8af443e5 4043 pr_warn("%d: Can't enable device\n", btv->c.nr);
1da177e4
LT		 4044 return -EIO;
4045 }
284901a9 4046 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
8af443e5 4047 pr_warn("%d: No suitable DMA available\n", btv->c.nr);
1da177e4 4048 return -EIO;
4ac97914 4049 }
1da177e4
LT		 4050 if (!request_mem_region(pci_resource_start(dev,0),
4051 pci_resource_len(dev,0),
74fc7bd9 4052 btv->c.v4l2_dev.name)) {
8af443e5
JP		 4053 pr_warn("%d: can't request iomem (0x%llx)\n",
4054 btv->c.nr,
4055 (unsigned long long)pci_resource_start(dev, 0));
1da177e4
LT		 4056 return -EBUSY;
4057 }
4ac97914 4058 pci_set_master(dev);
1da177e4 4059 pci_set_command(dev);
74fc7bd9
HV		 4060
4061 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4062 if (result < 0) {
8af443e5 4063 pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr);
74fc7bd9
HV		 4064 goto fail0;
4065 }
01df530c
HV		 4066 hdl = &btv->ctrl_handler;
4067 v4l2_ctrl_handler_init(hdl, 20);
4068 btv->c.v4l2_dev.ctrl_handler = hdl;
4069 v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6);
1da177e4 4070
abd34d8d 4071 btv->revision = dev->revision;
4ac97914 4072 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
8af443e5
JP		 4073 pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n",
4074 bttv_num, btv->id, btv->revision, pci_name(dev),
4075 btv->c.pci->irq, lat,
4076 (unsigned long long)pci_resource_start(dev, 0));
1da177e4
LT		 4077 schedule();
4078
5f1693fe
AM		 4079 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4080 if (NULL == btv->bt848_mmio) {
8af443e5 4081 pr_err("%d: ioremap() failed\n", btv->c.nr);
1da177e4
LT		 4082 result = -EIO;
4083 goto fail1;
4084 }
4085
4ac97914 4086 /* identify card */
1da177e4
LT		 4087 bttv_idcard(btv);
4088
4ac97914 4089 /* disable irqs, register irq handler */
1da177e4 4090 btwrite(0, BT848_INT_MASK);
4ac97914 4091 result = request_irq(btv->c.pci->irq, bttv_irq,
3e018fe4 4092 IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv);
4ac97914 4093 if (result < 0) {
8af443e5
JP		 4094 pr_err("%d: can't get IRQ %d\n",
4095 bttv_num, btv->c.pci->irq);
1da177e4 4096 goto fail1;
4ac97914 4097 }
1da177e4
LT		 4098
4099 if (0 != bttv_handle_chipset(btv)) {
4100 result = -EIO;
4101 goto fail2;
4ac97914 4102 }
1da177e4
LT		 4103
4104 /* init options from insmod args */
4105 btv->opt_combfilter = combfilter;
01df530c
HV		 4106 bttv_ctrl_combfilter.def = combfilter;
4107 bttv_ctrl_lumafilter.def = lumafilter;
1da177e4 4108 btv->opt_automute = automute;
01df530c
HV		 4109 bttv_ctrl_automute.def = automute;
4110 bttv_ctrl_agc_crush.def = agc_crush;
1da177e4 4111 btv->opt_vcr_hack = vcr_hack;
01df530c
HV		 4112 bttv_ctrl_vcr_hack.def = vcr_hack;
4113 bttv_ctrl_whitecrush_upper.def = whitecrush_upper;
4114 bttv_ctrl_whitecrush_lower.def = whitecrush_lower;
060d3027 4115 btv->opt_uv_ratio = uv_ratio;
01df530c
HV		 4116 bttv_ctrl_uv_ratio.def = uv_ratio;
4117 bttv_ctrl_full_luma.def = full_luma_range;
4118 bttv_ctrl_coring.def = coring;
1da177e4
LT		 4119
4120 /* fill struct bttv with some useful defaults */
4121 btv->init.btv = btv;
4122 btv->init.ov.w.width = 320;
4123 btv->init.ov.w.height = 240;
c96dd071 4124 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
1da177e4
LT		 4125 btv->init.width = 320;
4126 btv->init.height = 240;
c13eb703
HV		 4127 btv->init.ov.w.width = 320;
4128 btv->init.ov.w.height = 240;
4129 btv->init.ov.field = V4L2_FIELD_INTERLACED;
1da177e4
LT		 4130 btv->input = 0;
4131
01df530c
HV		 4132 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4133 V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768);
4134 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4135 V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00);
4136 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4137 V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768);
4138 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4139 V4L2_CID_COLOR_KILLER, 0, 1, 1, 0);
4140 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4141 V4L2_CID_HUE, 0, 0xff00, 0x100, 32768);
4142 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4143 V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc);
4144 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4145 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
4146 if (btv->volume_gpio)
4147 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
4148 V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00);
4149 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL);
4150 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL);
4151 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL);
4152 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL);
4153 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL);
4154 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL);
4155 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL);
4156 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL);
4157 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL);
4158 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL);
4159
1da177e4 4160 /* initialize hardware */
4ac97914
MCC		 4161 if (bttv_gpio)
4162 bttv_gpio_tracking(btv,"pre-init");
1da177e4
LT		 4163
4164 bttv_risc_init_main(btv);
4165 init_bt848(btv);
4166
4167 /* gpio */
4ac97914
MCC		 4168 btwrite(0x00, BT848_GPIO_REG_INP);
4169 btwrite(0x00, BT848_GPIO_OUT_EN);
4170 if (bttv_verbose)
4171 bttv_gpio_tracking(btv,"init");
1da177e4 4172
4ac97914
MCC		 4173 /* needs to be done before i2c is registered */
4174 bttv_init_card1(btv);
1da177e4 4175
4ac97914
MCC		 4176 /* register i2c + gpio */
4177 init_bttv_i2c(btv);
1da177e4 4178
4ac97914
MCC		 4179 /* some card-specific stuff (needs working i2c) */
4180 bttv_init_card2(btv);
2c905778 4181 bttv_init_tuner(btv);
76ea992a
HV		 4182 if (btv->tuner_type != TUNER_ABSENT) {
4183 bttv_set_frequency(btv, &init_freq);
4184 btv->radio_freq = 90500 * 16; /* 90.5Mhz default */
4185 }
6795cc55 4186 btv->std = V4L2_STD_PAL;
1da177e4 4187 init_irqreg(btv);
f8e1b699
HV		 4188 if (!bttv_tvcards[btv->c.type].no_video)
4189 v4l2_ctrl_handler_setup(hdl);
01df530c
HV		 4190 if (hdl->error) {
4191 result = hdl->error;
4192 goto fail2;
4193 }
da9f07f2
FS		 4194 /* mute device */
4195 audio_mute(btv, 1);
4196
4ac97914 4197 /* register video4linux + input */
1da177e4 4198 if (!bttv_tvcards[btv->c.type].no_video) {
01df530c
HV		 4199 v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl,
4200 v4l2_ctrl_radio_filter);
4201 if (btv->radio_ctrl_handler.error) {
4202 result = btv->radio_ctrl_handler.error;
4203 goto fail2;
4204 }
333408f2 4205 set_input(btv, 0, btv->tvnorm);
e5bd0260
MS		 4206 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4207 btv->crop[1] = btv->crop[0]; /* current = default */
4208 disclaim_vbi_lines(btv);
4209 disclaim_video_lines(btv);
01df530c 4210 bttv_register_video(btv);
1da177e4
LT		 4211 }
4212
f992a497
JW		 4213 /* add subdevices and autoload dvb-bt8xx if needed */
4214 if (bttv_tvcards[btv->c.type].has_dvb) {
1da177e4 4215 bttv_sub_add_device(&btv->c, "dvb");
f992a497
JW		 4216 request_modules(btv);
4217 }
1da177e4 4218
d90a4ae4
JD		 4219 if (!disable_ir) {
4220 init_bttv_i2c_ir(btv);
4221 bttv_input_init(btv);
4222 }
4abdfed5 4223
1da177e4
LT		 4224 /* everything is fine */
4225 bttv_num++;
4ac97914 4226 return 0;
1da177e4 4227
74fc7bd9 4228fail2:
4ac97914 4229 free_irq(btv->c.pci->irq,btv);
1da177e4 4230
74fc7bd9 4231fail1:
01df530c
HV		 4232 v4l2_ctrl_handler_free(&btv->ctrl_handler);
4233 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
74fc7bd9
HV		 4234 v4l2_device_unregister(&btv->c.v4l2_dev);
4235
4236fail0:
1da177e4
LT		 4237 if (btv->bt848_mmio)
4238 iounmap(btv->bt848_mmio);
4239 release_mem_region(pci_resource_start(btv->c.pci,0),
4240 pci_resource_len(btv->c.pci,0));
1da177e4
LT		 4241 return result;
4242}
4243
4c62e976 4244static void bttv_remove(struct pci_dev *pci_dev)
1da177e4 4245{
74fc7bd9
HV		 4246 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4247 struct bttv *btv = to_bttv(v4l2_dev);
1da177e4
LT		 4248
4249 if (bttv_verbose)
8af443e5 4250 pr_info("%d: unloading\n", btv->c.nr);
1da177e4 4251
707bcf32
TH		 4252 if (bttv_tvcards[btv->c.type].has_dvb)
4253 flush_request_modules(btv);
4254
4ac97914 4255 /* shutdown everything (DMA+IRQs) */
1da177e4
LT		 4256 btand(~15, BT848_GPIO_DMA_CTL);
4257 btwrite(0, BT848_INT_MASK);
4258 btwrite(~0x0, BT848_INT_STAT);
4259 btwrite(0x0, BT848_GPIO_OUT_EN);
4260 if (bttv_gpio)
4261 bttv_gpio_tracking(btv,"cleanup");
4262
4263 /* tell gpio modules we are leaving ... */
4264 btv->shutdown=1;
4abdfed5 4265 bttv_input_fini(btv);
889aee80 4266 bttv_sub_del_devices(&btv->c);
1da177e4 4267
4ac97914 4268 /* unregister i2c_bus + input */
1da177e4
LT		 4269 fini_bttv_i2c(btv);
4270
4271 /* unregister video4linux */
4272 bttv_unregister_video(btv);
4273
4274 /* free allocated memory */
01df530c
HV		 4275 v4l2_ctrl_handler_free(&btv->ctrl_handler);
4276 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
1da177e4
LT		 4277 btcx_riscmem_free(btv->c.pci,&btv->main);
4278
01df530c 4279 /* free resources */
4ac97914 4280 free_irq(btv->c.pci->irq,btv);
1da177e4 4281 iounmap(btv->bt848_mmio);
4ac97914
MCC		 4282 release_mem_region(pci_resource_start(btv->c.pci,0),
4283 pci_resource_len(btv->c.pci,0));
1da177e4 4284
74fc7bd9 4285 v4l2_device_unregister(&btv->c.v4l2_dev);
4b10d3b6
TP		 4286 bttvs[btv->c.nr] = NULL;
4287 kfree(btv);
4288
4ac97914 4289 return;
1da177e4
LT		 4290}
4291
17bc98a4 4292#ifdef CONFIG_PM
1da177e4
LT		 4293static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4294{
74fc7bd9
HV		 4295 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4296 struct bttv *btv = to_bttv(v4l2_dev);
1da177e4
LT		 4297 struct bttv_buffer_set idle;
4298 unsigned long flags;
4299
8af443e5 4300 dprintk("%d: suspend %d\n", btv->c.nr, state.event);
1da177e4
LT		 4301
4302 /* stop dma + irqs */
4303 spin_lock_irqsave(&btv->s_lock,flags);
4304 memset(&idle, 0, sizeof(idle));
4305 btv->state.video = btv->curr;
4306 btv->state.vbi = btv->cvbi;
4307 btv->state.loop_irq = btv->loop_irq;
4308 btv->curr = idle;
4309 btv->loop_irq = 0;
4310 bttv_buffer_activate_video(btv, &idle);
4311 bttv_buffer_activate_vbi(btv, NULL);
4312 bttv_set_dma(btv, 0);
4313 btwrite(0, BT848_INT_MASK);
4314 spin_unlock_irqrestore(&btv->s_lock,flags);
4315
4316 /* save bt878 state */
4317 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4318 btv->state.gpio_data = gpio_read();
4319
4320 /* save pci state */
4321 pci_save_state(pci_dev);
4322 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4323 pci_disable_device(pci_dev);
4324 btv->state.disabled = 1;
4325 }
4326 return 0;
4327}
4328
4329static int bttv_resume(struct pci_dev *pci_dev)
4330{
74fc7bd9
HV		 4331 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4332 struct bttv *btv = to_bttv(v4l2_dev);
1da177e4 4333 unsigned long flags;
08adb9e2 4334 int err;
1da177e4 4335
8af443e5 4336 dprintk("%d: resume\n", btv->c.nr);
1da177e4
LT		 4337
4338 /* restore pci state */
4339 if (btv->state.disabled) {
08adb9e2
MCC		 4340 err=pci_enable_device(pci_dev);
4341 if (err) {
8af443e5 4342 pr_warn("%d: Can't enable device\n", btv->c.nr);
08adb9e2
MCC		 4343 return err;
4344 }
1da177e4
LT		 4345 btv->state.disabled = 0;
4346 }
08adb9e2
MCC		 4347 err=pci_set_power_state(pci_dev, PCI_D0);
4348 if (err) {
4349 pci_disable_device(pci_dev);
8af443e5 4350 pr_warn("%d: Can't enable device\n", btv->c.nr);
08adb9e2
MCC		 4351 btv->state.disabled = 1;
4352 return err;
4353 }
4354
1da177e4
LT		 4355 pci_restore_state(pci_dev);
4356
4357 /* restore bt878 state */
4358 bttv_reinit_bt848(btv);
4359 gpio_inout(0xffffff, btv->state.gpio_enable);
4360 gpio_write(btv->state.gpio_data);
4361
4362 /* restart dma */
4363 spin_lock_irqsave(&btv->s_lock,flags);
4364 btv->curr = btv->state.video;
4365 btv->cvbi = btv->state.vbi;
4366 btv->loop_irq = btv->state.loop_irq;
4367 bttv_buffer_activate_video(btv, &btv->curr);
4368 bttv_buffer_activate_vbi(btv, btv->cvbi);
4369 bttv_set_dma(btv, 0);
4370 spin_unlock_irqrestore(&btv->s_lock,flags);
4371 return 0;
4372}
17bc98a4 4373#endif
1da177e4
LT		 4374
4375static struct pci_device_id bttv_pci_tbl[] = {
76e9741d
JP		 4376 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4377 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4378 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4379 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
c540d9f1 4380 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
4ac97914 4381 {0,}
1da177e4
LT		 4382};
4383
4384MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4385
4386static struct pci_driver bttv_pci_driver = {
4ac97914
MCC		 4387 .name = "bttv",
4388 .id_table = bttv_pci_tbl,
4389 .probe = bttv_probe,
4c62e976 4390 .remove = bttv_remove,
17bc98a4 4391#ifdef CONFIG_PM
1da177e4
LT		 4392 .suspend = bttv_suspend,
4393 .resume = bttv_resume,
17bc98a4 4394#endif
1da177e4
LT		 4395};
4396
7d44e892 4397static int __init bttv_init_module(void)
1da177e4 4398{
c526e224
RD		 4399 int ret;
4400
1da177e4
LT		 4401 bttv_num = 0;
4402
8af443e5 4403 pr_info("driver version %s loaded\n", BTTV_VERSION);
1da177e4
LT		 4404 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4405 gbuffers = 2;
f41b6961 4406 if (gbufsize > BTTV_MAX_FBUF)
1da177e4
LT		 4407 gbufsize = BTTV_MAX_FBUF;
4408 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4409 if (bttv_verbose)
8af443e5
JP		 4410 pr_info("using %d buffers with %dk (%d pages) each for capture\n",
4411 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
1da177e4
LT		 4412
4413 bttv_check_chipset();
4414
c526e224
RD		 4415 ret = bus_register(&bttv_sub_bus_type);
4416 if (ret < 0) {
8af443e5 4417 pr_warn("bus_register error: %d\n", ret);
c526e224
RD		 4418 return ret;
4419 }
9e7e85eb
AM		 4420 ret = pci_register_driver(&bttv_pci_driver);
4421 if (ret < 0)
4422 bus_unregister(&bttv_sub_bus_type);
4423
4424 return ret;
1da177e4
LT		 4425}
4426
7d44e892 4427static void __exit bttv_cleanup_module(void)
1da177e4
LT		 4428{
4429 pci_unregister_driver(&bttv_pci_driver);
4430 bus_unregister(&bttv_sub_bus_type);
1da177e4
LT		 4431}
4432
4433module_init(bttv_init_module);
4434module_exit(bttv_cleanup_module);
Ubuntu Artful kernel mirror