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