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