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