]> 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] v4l: 692: bttv coding style and card ids
[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;
e1e70a26
BP		 766 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
767 btv->c.nr,btv->pll.pll_ifreq);
1da177e4
LT		 768 btwrite(0x00,BT848_TGCTRL);
769 btwrite(0x00,BT848_PLL_XCI);
770 btv->pll.pll_current = 0;
771 return;
772 }
773
e1e70a26
BP		 774 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
775 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1da177e4
LT		 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 */
e1e70a26 780 bttv_printk(".");
1da177e4
LT		 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;
e1e70a26 788 bttv_printk(" ok\n");
1da177e4
LT		 789 return;
790 }
791 }
792 btv->pll.pll_current = -1;
e1e70a26 793 bttv_printk("failed\n");
1da177e4
LT		 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);
2ea75330 1954 kfree(fh->ov.clips);
1da177e4
LT		 1955 fh->ov.clips = clips;
1956 fh->ov.nclips = n;
1957
1958 fh->ov.w = win->w;
1959 fh->ov.field = win->field;
1960 fh->ov.setup_ok = 1;
1961 btv->init.ov.w.width = win->w.width;
1962 btv->init.ov.w.height = win->w.height;
1963 btv->init.ov.field = win->field;
1964
1965 /* update overlay if needed */
1966 retval = 0;
1967 if (check_btres(fh, RESOURCE_OVERLAY)) {
1968 struct bttv_buffer *new;
1969
1970 new = videobuf_alloc(sizeof(*new));
1971 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
1972 retval = bttv_switch_overlay(btv,fh,new);
1973 }
1974 up(&fh->cap.lock);
1975 return retval;
1976}
1977
1978/* ----------------------------------------------------------------------- */
1979
1980static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
1981{
1982 struct videobuf_queue* q = NULL;
1983
1984 switch (fh->type) {
1985 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1986 q = &fh->cap;
1987 break;
1988 case V4L2_BUF_TYPE_VBI_CAPTURE:
1989 q = &fh->vbi;
1990 break;
1991 default:
1992 BUG();
1993 }
1994 return q;
1995}
1996
1997static int bttv_resource(struct bttv_fh *fh)
1998{
1999 int res = 0;
2000
2001 switch (fh->type) {
2002 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2003 res = RESOURCE_VIDEO;
2004 break;
2005 case V4L2_BUF_TYPE_VBI_CAPTURE:
2006 res = RESOURCE_VBI;
2007 break;
2008 default:
2009 BUG();
2010 }
2011 return res;
2012}
2013
2014static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2015{
2016 struct videobuf_queue *q = bttv_queue(fh);
2017 int res = bttv_resource(fh);
2018
2019 if (check_btres(fh,res))
2020 return -EBUSY;
2021 if (videobuf_queue_is_busy(q))
2022 return -EBUSY;
2023 fh->type = type;
2024 return 0;
2025}
2026
2027static int bttv_g_fmt(struct bttv_fh *fh, struct v4l2_format *f)
2028{
2029 switch (f->type) {
2030 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2031 memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
2032 f->fmt.pix.width = fh->width;
2033 f->fmt.pix.height = fh->height;
2034 f->fmt.pix.field = fh->cap.field;
2035 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2036 f->fmt.pix.bytesperline =
2037 (f->fmt.pix.width * fh->fmt->depth) >> 3;
2038 f->fmt.pix.sizeimage =
2039 f->fmt.pix.height * f->fmt.pix.bytesperline;
2040 return 0;
2041 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2042 memset(&f->fmt.win,0,sizeof(struct v4l2_window));
2043 f->fmt.win.w = fh->ov.w;
2044 f->fmt.win.field = fh->ov.field;
2045 return 0;
2046 case V4L2_BUF_TYPE_VBI_CAPTURE:
2047 bttv_vbi_get_fmt(fh,f);
2048 return 0;
2049 default:
2050 return -EINVAL;
2051 }
2052}
2053
2054static int bttv_try_fmt(struct bttv_fh *fh, struct bttv *btv,
2055 struct v4l2_format *f)
2056{
2057 switch (f->type) {
2058 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2059 {
2060 const struct bttv_format *fmt;
2061 enum v4l2_field field;
2062 unsigned int maxw,maxh;
2063
2064 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2065 if (NULL == fmt)
2066 return -EINVAL;
2067
2068 /* fixup format */
2069 maxw = bttv_tvnorms[btv->tvnorm].swidth;
2070 maxh = bttv_tvnorms[btv->tvnorm].sheight;
2071 field = f->fmt.pix.field;
2072 if (V4L2_FIELD_ANY == field)
2073 field = (f->fmt.pix.height > maxh/2)
2074 ? V4L2_FIELD_INTERLACED
2075 : V4L2_FIELD_BOTTOM;
2076 if (V4L2_FIELD_SEQ_BT == field)
2077 field = V4L2_FIELD_SEQ_TB;
2078 switch (field) {
2079 case V4L2_FIELD_TOP:
2080 case V4L2_FIELD_BOTTOM:
2081 case V4L2_FIELD_ALTERNATE:
2082 maxh = maxh/2;
2083 break;
2084 case V4L2_FIELD_INTERLACED:
2085 break;
2086 case V4L2_FIELD_SEQ_TB:
2087 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2088 return -EINVAL;
2089 break;
2090 default:
2091 return -EINVAL;
2092 }
2093
2094 /* update data for the application */
2095 f->fmt.pix.field = field;
2096 if (f->fmt.pix.width < 48)
2097 f->fmt.pix.width = 48;
2098 if (f->fmt.pix.height < 32)
2099 f->fmt.pix.height = 32;
2100 if (f->fmt.pix.width > maxw)
2101 f->fmt.pix.width = maxw;
2102 if (f->fmt.pix.height > maxh)
2103 f->fmt.pix.height = maxh;
2104 f->fmt.pix.width &= ~0x03;
2105 f->fmt.pix.bytesperline =
2106 (f->fmt.pix.width * fmt->depth) >> 3;
2107 f->fmt.pix.sizeimage =
2108 f->fmt.pix.height * f->fmt.pix.bytesperline;
2109
2110 return 0;
2111 }
2112 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2113 return verify_window(&bttv_tvnorms[btv->tvnorm],
2114 &f->fmt.win, 1);
2115 case V4L2_BUF_TYPE_VBI_CAPTURE:
2116 bttv_vbi_try_fmt(fh,f);
2117 return 0;
2118 default:
2119 return -EINVAL;
2120 }
2121}
2122
2123static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
2124 struct v4l2_format *f)
2125{
2126 int retval;
2127
2128 switch (f->type) {
2129 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2130 {
2131 const struct bttv_format *fmt;
2132
2133 retval = bttv_switch_type(fh,f->type);
2134 if (0 != retval)
2135 return retval;
2136 retval = bttv_try_fmt(fh,btv,f);
2137 if (0 != retval)
2138 return retval;
2139 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2140
2141 /* update our state informations */
2142 down(&fh->cap.lock);
2143 fh->fmt = fmt;
2144 fh->cap.field = f->fmt.pix.field;
2145 fh->cap.last = V4L2_FIELD_NONE;
2146 fh->width = f->fmt.pix.width;
2147 fh->height = f->fmt.pix.height;
2148 btv->init.fmt = fmt;
2149 btv->init.width = f->fmt.pix.width;
2150 btv->init.height = f->fmt.pix.height;
2151 up(&fh->cap.lock);
2152
2153 return 0;
2154 }
2155 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
4dcef524
MCC		 2156 if (no_overlay > 0) {
2157 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2158 return -EINVAL;
2159 }
1da177e4
LT		 2160 return setup_window(fh, btv, &f->fmt.win, 1);
2161 case V4L2_BUF_TYPE_VBI_CAPTURE:
2162 retval = bttv_switch_type(fh,f->type);
2163 if (0 != retval)
2164 return retval;
2165 if (locked_btres(fh->btv, RESOURCE_VBI))
2166 return -EBUSY;
2167 bttv_vbi_try_fmt(fh,f);
2168 bttv_vbi_setlines(fh,btv,f->fmt.vbi.count[0]);
2169 bttv_vbi_get_fmt(fh,f);
2170 return 0;
2171 default:
2172 return -EINVAL;
2173 }
2174}
2175
2176static int bttv_do_ioctl(struct inode *inode, struct file *file,
2177 unsigned int cmd, void *arg)
2178{
2179 struct bttv_fh *fh = file->private_data;
2180 struct bttv *btv = fh->btv;
2181 unsigned long flags;
2182 int retval = 0;
2183
2184 if (bttv_debug > 1) {
2185 switch (_IOC_TYPE(cmd)) {
2186 case 'v':
2187 printk("bttv%d: ioctl 0x%x (v4l1, VIDIOC%s)\n",
2188 btv->c.nr, cmd, (_IOC_NR(cmd) < V4L1_IOCTLS) ?
2189 v4l1_ioctls[_IOC_NR(cmd)] : "???");
2190 break;
2191 case 'V':
2192 printk("bttv%d: ioctl 0x%x (v4l2, %s)\n",
2193 btv->c.nr, cmd, v4l2_ioctl_names[_IOC_NR(cmd)]);
2194 break;
2195 default:
2196 printk("bttv%d: ioctl 0x%x (???)\n",
2197 btv->c.nr, cmd);
2198 }
2199 }
2200 if (btv->errors)
2201 bttv_reinit_bt848(btv);
2202
2203 switch (cmd) {
2204 case VIDIOCSFREQ:
2205 case VIDIOCSTUNER:
2206 case VIDIOCSCHAN:
2207 case VIDIOC_S_CTRL:
2208 case VIDIOC_S_STD:
2209 case VIDIOC_S_INPUT:
2210 case VIDIOC_S_TUNER:
2211 case VIDIOC_S_FREQUENCY:
2212 retval = v4l2_prio_check(&btv->prio,&fh->prio);
2213 if (0 != retval)
2214 return retval;
2215 };
2216
2217 switch (cmd) {
2218
2219 /* *** v4l1 *** ************************************************ */
2220 case VIDIOCGCAP:
2221 {
2222 struct video_capability *cap = arg;
2223
2224 memset(cap,0,sizeof(*cap));
2225 strcpy(cap->name,btv->video_dev->name);
2226 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2227 /* vbi */
2228 cap->type = VID_TYPE_TUNER|VID_TYPE_TELETEXT;
2229 } else {
2230 /* others */
2231 cap->type = VID_TYPE_CAPTURE|
2232 VID_TYPE_TUNER|
1da177e4
LT		 2233 VID_TYPE_CLIPPING|
2234 VID_TYPE_SCALES;
4dcef524
MCC		 2235 if (no_overlay <= 0)
2236 cap->type |= VID_TYPE_OVERLAY;
2237
1da177e4
LT		 2238 cap->maxwidth = bttv_tvnorms[btv->tvnorm].swidth;
2239 cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
2240 cap->minwidth = 48;
2241 cap->minheight = 32;
2242 }
2243 cap->channels = bttv_tvcards[btv->c.type].video_inputs;
2244 cap->audios = bttv_tvcards[btv->c.type].audio_inputs;
2245 return 0;
2246 }
2247
2248 case VIDIOCGPICT:
2249 {
2250 struct video_picture *pic = arg;
2251
2252 memset(pic,0,sizeof(*pic));
2253 pic->brightness = btv->bright;
2254 pic->contrast = btv->contrast;
2255 pic->hue = btv->hue;
2256 pic->colour = btv->saturation;
2257 if (fh->fmt) {
2258 pic->depth = fh->fmt->depth;
2259 pic->palette = fh->fmt->palette;
2260 }
2261 return 0;
2262 }
2263 case VIDIOCSPICT:
2264 {
2265 struct video_picture *pic = arg;
2266 const struct bttv_format *fmt;
2267
2268 fmt = format_by_palette(pic->palette);
2269 if (NULL == fmt)
2270 return -EINVAL;
2271 down(&fh->cap.lock);
2272 if (fmt->depth != pic->depth) {
2273 retval = -EINVAL;
2274 goto fh_unlock_and_return;
2275 }
2276 fh->ovfmt = fmt;
2277 fh->fmt = fmt;
2278 btv->init.ovfmt = fmt;
2279 btv->init.fmt = fmt;
2280 if (bigendian) {
2281 /* dirty hack time: swap bytes for overlay if the
2282 display adaptor is big endian (insmod option) */
2283 if (fmt->palette == VIDEO_PALETTE_RGB555 ||
2284 fmt->palette == VIDEO_PALETTE_RGB565 ||
2285 fmt->palette == VIDEO_PALETTE_RGB32) {
2286 fh->ovfmt = fmt+1;
2287 }
2288 }
2289 bt848_bright(btv,pic->brightness);
2290 bt848_contrast(btv,pic->contrast);
2291 bt848_hue(btv,pic->hue);
2292 bt848_sat(btv,pic->colour);
2293 up(&fh->cap.lock);
2294 return 0;
2295 }
2296
2297 case VIDIOCGWIN:
2298 {
2299 struct video_window *win = arg;
2300
2301 memset(win,0,sizeof(*win));
2302 win->x = fh->ov.w.left;
2303 win->y = fh->ov.w.top;
2304 win->width = fh->ov.w.width;
2305 win->height = fh->ov.w.height;
2306 return 0;
2307 }
2308 case VIDIOCSWIN:
2309 {
2310 struct video_window *win = arg;
2311 struct v4l2_window w2;
2312
4dcef524
MCC		 2313 if (no_overlay > 0) {
2314 printk ("VIDIOCSWIN: no_overlay\n");
2315 return -EINVAL;
2316 }
2317
1da177e4
LT		 2318 w2.field = V4L2_FIELD_ANY;
2319 w2.w.left = win->x;
2320 w2.w.top = win->y;
2321 w2.w.width = win->width;
2322 w2.w.height = win->height;
2323 w2.clipcount = win->clipcount;
2324 w2.clips = (struct v4l2_clip __user *)win->clips;
2325 retval = setup_window(fh, btv, &w2, 0);
2326 if (0 == retval) {
2327 /* on v4l1 this ioctl affects the read() size too */
2328 fh->width = fh->ov.w.width;
2329 fh->height = fh->ov.w.height;
2330 btv->init.width = fh->ov.w.width;
2331 btv->init.height = fh->ov.w.height;
2332 }
2333 return retval;
2334 }
2335
2336 case VIDIOCGFBUF:
2337 {
2338 struct video_buffer *fbuf = arg;
2339
2340 fbuf->base = btv->fbuf.base;
2341 fbuf->width = btv->fbuf.fmt.width;
2342 fbuf->height = btv->fbuf.fmt.height;
2343 fbuf->bytesperline = btv->fbuf.fmt.bytesperline;
2344 if (fh->ovfmt)
2345 fbuf->depth = fh->ovfmt->depth;
2346 return 0;
2347 }
2348 case VIDIOCSFBUF:
2349 {
2350 struct video_buffer *fbuf = arg;
2351 const struct bttv_format *fmt;
2352 unsigned long end;
2353
2354 if(!capable(CAP_SYS_ADMIN) &&
2355 !capable(CAP_SYS_RAWIO))
2356 return -EPERM;
2357 end = (unsigned long)fbuf->base +
2358 fbuf->height * fbuf->bytesperline;
2359 down(&fh->cap.lock);
2360 retval = -EINVAL;
2361
2362 switch (fbuf->depth) {
2363 case 8:
2364 fmt = format_by_palette(VIDEO_PALETTE_HI240);
2365 break;
2366 case 16:
2367 fmt = format_by_palette(VIDEO_PALETTE_RGB565);
2368 break;
2369 case 24:
2370 fmt = format_by_palette(VIDEO_PALETTE_RGB24);
2371 break;
2372 case 32:
2373 fmt = format_by_palette(VIDEO_PALETTE_RGB32);
2374 break;
2375 case 15:
2376 fbuf->depth = 16;
2377 fmt = format_by_palette(VIDEO_PALETTE_RGB555);
2378 break;
2379 default:
2380 fmt = NULL;
2381 break;
2382 }
2383 if (NULL == fmt)
2384 goto fh_unlock_and_return;
2385
2386 fh->ovfmt = fmt;
2387 fh->fmt = fmt;
2388 btv->init.ovfmt = fmt;
2389 btv->init.fmt = fmt;
2390 btv->fbuf.base = fbuf->base;
2391 btv->fbuf.fmt.width = fbuf->width;
2392 btv->fbuf.fmt.height = fbuf->height;
2393 if (fbuf->bytesperline)
2394 btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
2395 else
2396 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
2397 up(&fh->cap.lock);
2398 return 0;
2399 }
2400
2401 case VIDIOCCAPTURE:
2402 case VIDIOC_OVERLAY:
2403 {
2404 struct bttv_buffer *new;
2405 int *on = arg;
2406
2407 if (*on) {
2408 /* verify args */
2409 if (NULL == btv->fbuf.base)
2410 return -EINVAL;
2411 if (!fh->ov.setup_ok) {
2412 dprintk("bttv%d: overlay: !setup_ok\n",btv->c.nr);
2413 return -EINVAL;
2414 }
2415 }
2416
2417 if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
2418 return -EBUSY;
2419
2420 down(&fh->cap.lock);
2421 if (*on) {
2422 fh->ov.tvnorm = btv->tvnorm;
2423 new = videobuf_alloc(sizeof(*new));
2424 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2425 } else {
2426 new = NULL;
2427 }
2428
2429 /* switch over */
2430 retval = bttv_switch_overlay(btv,fh,new);
2431 up(&fh->cap.lock);
2432 return retval;
2433 }
2434
2435 case VIDIOCGMBUF:
2436 {
2437 struct video_mbuf *mbuf = arg;
2438 unsigned int i;
2439
2440 down(&fh->cap.lock);
2441 retval = videobuf_mmap_setup(&fh->cap,gbuffers,gbufsize,
2442 V4L2_MEMORY_MMAP);
2443 if (retval < 0)
2444 goto fh_unlock_and_return;
2445 memset(mbuf,0,sizeof(*mbuf));
2446 mbuf->frames = gbuffers;
2447 mbuf->size = gbuffers * gbufsize;
2448 for (i = 0; i < gbuffers; i++)
2449 mbuf->offsets[i] = i * gbufsize;
2450 up(&fh->cap.lock);
2451 return 0;
2452 }
2453 case VIDIOCMCAPTURE:
2454 {
2455 struct video_mmap *vm = arg;
2456 struct bttv_buffer *buf;
2457 enum v4l2_field field;
2458
2459 if (vm->frame >= VIDEO_MAX_FRAME)
2460 return -EINVAL;
2461
2462 down(&fh->cap.lock);
2463 retval = -EINVAL;
2464 buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
2465 if (NULL == buf)
2466 goto fh_unlock_and_return;
2467 if (0 == buf->vb.baddr)
2468 goto fh_unlock_and_return;
2469 if (buf->vb.state == STATE_QUEUED ||
2470 buf->vb.state == STATE_ACTIVE)
2471 goto fh_unlock_and_return;
2472
2473 field = (vm->height > bttv_tvnorms[btv->tvnorm].sheight/2)
2474 ? V4L2_FIELD_INTERLACED
2475 : V4L2_FIELD_BOTTOM;
2476 retval = bttv_prepare_buffer(btv,buf,
2477 format_by_palette(vm->format),
2478 vm->width,vm->height,field);
2479 if (0 != retval)
2480 goto fh_unlock_and_return;
2481 spin_lock_irqsave(&btv->s_lock,flags);
2482 buffer_queue(&fh->cap,&buf->vb);
2483 spin_unlock_irqrestore(&btv->s_lock,flags);
2484 up(&fh->cap.lock);
2485 return 0;
2486 }
2487 case VIDIOCSYNC:
2488 {
2489 int *frame = arg;
2490 struct bttv_buffer *buf;
2491
2492 if (*frame >= VIDEO_MAX_FRAME)
2493 return -EINVAL;
2494
2495 down(&fh->cap.lock);
2496 retval = -EINVAL;
2497 buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
2498 if (NULL == buf)
2499 goto fh_unlock_and_return;
2500 retval = videobuf_waiton(&buf->vb,0,1);
2501 if (0 != retval)
2502 goto fh_unlock_and_return;
2503 switch (buf->vb.state) {
2504 case STATE_ERROR:
2505 retval = -EIO;
2506 /* fall through */
2507 case STATE_DONE:
2508 videobuf_dma_pci_sync(btv->c.pci,&buf->vb.dma);
2509 bttv_dma_free(btv,buf);
2510 break;
2511 default:
2512 retval = -EINVAL;
2513 break;
2514 }
2515 up(&fh->cap.lock);
2516 return retval;
2517 }
2518
2519 case VIDIOCGVBIFMT:
2520 {
2521 struct vbi_format *fmt = (void *) arg;
2522 struct v4l2_format fmt2;
2523
2524 if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
2525 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2526 if (0 != retval)
2527 return retval;
2528 }
2529 bttv_vbi_get_fmt(fh, &fmt2);
2530
2531 memset(fmt,0,sizeof(*fmt));
2532 fmt->sampling_rate = fmt2.fmt.vbi.sampling_rate;
2533 fmt->samples_per_line = fmt2.fmt.vbi.samples_per_line;
2534 fmt->sample_format = VIDEO_PALETTE_RAW;
2535 fmt->start[0] = fmt2.fmt.vbi.start[0];
2536 fmt->count[0] = fmt2.fmt.vbi.count[0];
2537 fmt->start[1] = fmt2.fmt.vbi.start[1];
2538 fmt->count[1] = fmt2.fmt.vbi.count[1];
2539 if (fmt2.fmt.vbi.flags & VBI_UNSYNC)
2540 fmt->flags |= V4L2_VBI_UNSYNC;
2541 if (fmt2.fmt.vbi.flags & VBI_INTERLACED)
2542 fmt->flags |= V4L2_VBI_INTERLACED;
2543 return 0;
2544 }
2545 case VIDIOCSVBIFMT:
2546 {
2547 struct vbi_format *fmt = (void *) arg;
2548 struct v4l2_format fmt2;
2549
2550 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2551 if (0 != retval)
2552 return retval;
2553 bttv_vbi_get_fmt(fh, &fmt2);
2554
2555 if (fmt->sampling_rate != fmt2.fmt.vbi.sampling_rate ||
2556 fmt->samples_per_line != fmt2.fmt.vbi.samples_per_line ||
2557 fmt->sample_format != VIDEO_PALETTE_RAW ||
2558 fmt->start[0] != fmt2.fmt.vbi.start[0] ||
2559 fmt->start[1] != fmt2.fmt.vbi.start[1] ||
2560 fmt->count[0] != fmt->count[1] ||
2561 fmt->count[0] < 1 ||
2562 fmt->count[0] > 32 /* VBI_MAXLINES */)
2563 return -EINVAL;
2564
2565 bttv_vbi_setlines(fh,btv,fmt->count[0]);
2566 return 0;
2567 }
2568
2569 case BTTV_VERSION:
2570 case VIDIOCGFREQ:
2571 case VIDIOCSFREQ:
2572 case VIDIOCGTUNER:
2573 case VIDIOCSTUNER:
2574 case VIDIOCGCHAN:
2575 case VIDIOCSCHAN:
2576 case VIDIOCGAUDIO:
2577 case VIDIOCSAUDIO:
2578 return bttv_common_ioctls(btv,cmd,arg);
2579
2580 /* *** v4l2 *** ************************************************ */
2581 case VIDIOC_QUERYCAP:
2582 {
2583 struct v4l2_capability *cap = arg;
2584
2585 if (0 == v4l2)
2586 return -EINVAL;
2587 strcpy(cap->driver,"bttv");
2588 strlcpy(cap->card,btv->video_dev->name,sizeof(cap->card));
2589 sprintf(cap->bus_info,"PCI:%s",pci_name(btv->c.pci));
2590 cap->version = BTTV_VERSION_CODE;
2591 cap->capabilities =
2592 V4L2_CAP_VIDEO_CAPTURE |
1da177e4
LT		 2593 V4L2_CAP_VBI_CAPTURE |
2594 V4L2_CAP_READWRITE |
2595 V4L2_CAP_STREAMING;
4dcef524
MCC		 2596 if (no_overlay <= 0)
2597 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2598
1da177e4
LT		 2599 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2600 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2601 cap->capabilities |= V4L2_CAP_TUNER;
2602 return 0;
2603 }
2604
2605 case VIDIOC_ENUM_FMT:
2606 {
2607 struct v4l2_fmtdesc *f = arg;
2608 enum v4l2_buf_type type;
2609 unsigned int i;
2610 int index;
2611
2612 type = f->type;
2613 if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
2614 /* vbi */
2615 index = f->index;
2616 if (0 != index)
2617 return -EINVAL;
2618 memset(f,0,sizeof(*f));
2619 f->index = index;
2620 f->type = type;
2621 f->pixelformat = V4L2_PIX_FMT_GREY;
2622 strcpy(f->description,"vbi data");
2623 return 0;
2624 }
2625
2626 /* video capture + overlay */
2627 index = -1;
2628 for (i = 0; i < BTTV_FORMATS; i++) {
2629 if (bttv_formats[i].fourcc != -1)
2630 index++;
2631 if ((unsigned int)index == f->index)
2632 break;
2633 }
2634 if (BTTV_FORMATS == i)
2635 return -EINVAL;
2636
2637 switch (f->type) {
2638 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2639 break;
2640 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2641 if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
2642 return -EINVAL;
2643 break;
2644 default:
2645 return -EINVAL;
2646 }
2647 memset(f,0,sizeof(*f));
2648 f->index = index;
2649 f->type = type;
2650 f->pixelformat = bttv_formats[i].fourcc;
2651 strlcpy(f->description,bttv_formats[i].name,sizeof(f->description));
2652 return 0;
2653 }
2654
2655 case VIDIOC_TRY_FMT:
2656 {
2657 struct v4l2_format *f = arg;
2658 return bttv_try_fmt(fh,btv,f);
2659 }
2660 case VIDIOC_G_FMT:
2661 {
2662 struct v4l2_format *f = arg;
2663 return bttv_g_fmt(fh,f);
2664 }
2665 case VIDIOC_S_FMT:
2666 {
2667 struct v4l2_format *f = arg;
2668 return bttv_s_fmt(fh,btv,f);
2669 }
2670
2671 case VIDIOC_G_FBUF:
2672 {
2673 struct v4l2_framebuffer *fb = arg;
2674
2675 *fb = btv->fbuf;
2676 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2677 if (fh->ovfmt)
2678 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2679 return 0;
2680 }
2681 case VIDIOC_S_FBUF:
2682 {
2683 struct v4l2_framebuffer *fb = arg;
2684 const struct bttv_format *fmt;
2685
2686 if(!capable(CAP_SYS_ADMIN) &&
2687 !capable(CAP_SYS_RAWIO))
2688 return -EPERM;
2689
2690 /* check args */
2691 fmt = format_by_fourcc(fb->fmt.pixelformat);
2692 if (NULL == fmt)
2693 return -EINVAL;
2694 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2695 return -EINVAL;
2696
2697 down(&fh->cap.lock);
2698 retval = -EINVAL;
2699 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2700 if (fb->fmt.width > bttv_tvnorms[btv->tvnorm].swidth)
2701 goto fh_unlock_and_return;
2702 if (fb->fmt.height > bttv_tvnorms[btv->tvnorm].sheight)
2703 goto fh_unlock_and_return;
2704 }
2705
2706 /* ok, accept it */
2707 btv->fbuf.base = fb->base;
2708 btv->fbuf.fmt.width = fb->fmt.width;
2709 btv->fbuf.fmt.height = fb->fmt.height;
2710 if (0 != fb->fmt.bytesperline)
2711 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2712 else
2713 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2714
2715 retval = 0;
2716 fh->ovfmt = fmt;
2717 btv->init.ovfmt = fmt;
2718 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2719 fh->ov.w.left = 0;
2720 fh->ov.w.top = 0;
2721 fh->ov.w.width = fb->fmt.width;
2722 fh->ov.w.height = fb->fmt.height;
2723 btv->init.ov.w.width = fb->fmt.width;
2724 btv->init.ov.w.height = fb->fmt.height;
2ea75330 2725 kfree(fh->ov.clips);
1da177e4
LT		 2726 fh->ov.clips = NULL;
2727 fh->ov.nclips = 0;
2728
2729 if (check_btres(fh, RESOURCE_OVERLAY)) {
2730 struct bttv_buffer *new;
2731
2732 new = videobuf_alloc(sizeof(*new));
2733 bttv_overlay_risc(btv,&fh->ov,fh->ovfmt,new);
2734 retval = bttv_switch_overlay(btv,fh,new);
2735 }
2736 }
2737 up(&fh->cap.lock);
2738 return retval;
2739 }
2740
2741 case VIDIOC_REQBUFS:
2742 return videobuf_reqbufs(bttv_queue(fh),arg);
2743
2744 case VIDIOC_QUERYBUF:
2745 return videobuf_querybuf(bttv_queue(fh),arg);
2746
2747 case VIDIOC_QBUF:
2748 return videobuf_qbuf(bttv_queue(fh),arg);
2749
2750 case VIDIOC_DQBUF:
2751 return videobuf_dqbuf(bttv_queue(fh),arg,
2752 file->f_flags & O_NONBLOCK);
2753
2754 case VIDIOC_STREAMON:
2755 {
2756 int res = bttv_resource(fh);
2757
2758 if (!check_alloc_btres(btv,fh,res))
2759 return -EBUSY;
2760 return videobuf_streamon(bttv_queue(fh));
2761 }
2762 case VIDIOC_STREAMOFF:
2763 {
2764 int res = bttv_resource(fh);
2765
2766 retval = videobuf_streamoff(bttv_queue(fh));
2767 if (retval < 0)
2768 return retval;
2769 free_btres(btv,fh,res);
2770 return 0;
2771 }
2772
2773 case VIDIOC_QUERYCTRL:
2774 {
2775 struct v4l2_queryctrl *c = arg;
2776 int i;
2777
2778 if ((c->id < V4L2_CID_BASE ||
2779 c->id >= V4L2_CID_LASTP1) &&
2780 (c->id < V4L2_CID_PRIVATE_BASE ||
2781 c->id >= V4L2_CID_PRIVATE_LASTP1))
2782 return -EINVAL;
2783 for (i = 0; i < BTTV_CTLS; i++)
2784 if (bttv_ctls[i].id == c->id)
2785 break;
2786 if (i == BTTV_CTLS) {
2787 *c = no_ctl;
2788 return 0;
2789 }
2790 *c = bttv_ctls[i];
2791 if (i >= 4 && i <= 8) {
2792 struct video_audio va;
2793 memset(&va,0,sizeof(va));
2794 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
2795 if (btv->audio_hook)
2796 btv->audio_hook(btv,&va,0);
2797 switch (bttv_ctls[i].id) {
2798 case V4L2_CID_AUDIO_VOLUME:
2799 if (!(va.flags & VIDEO_AUDIO_VOLUME))
2800 *c = no_ctl;
2801 break;
2802 case V4L2_CID_AUDIO_BALANCE:
2803 if (!(va.flags & VIDEO_AUDIO_BALANCE))
2804 *c = no_ctl;
2805 break;
2806 case V4L2_CID_AUDIO_BASS:
2807 if (!(va.flags & VIDEO_AUDIO_BASS))
2808 *c = no_ctl;
2809 break;
2810 case V4L2_CID_AUDIO_TREBLE:
2811 if (!(va.flags & VIDEO_AUDIO_TREBLE))
2812 *c = no_ctl;
2813 break;
2814 }
2815 }
2816 return 0;
2817 }
2818 case VIDIOC_G_CTRL:
2819 return get_control(btv,arg);
2820 case VIDIOC_S_CTRL:
2821 return set_control(btv,arg);
2822 case VIDIOC_G_PARM:
2823 {
2824 struct v4l2_streamparm *parm = arg;
2825 struct v4l2_standard s;
2826 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2827 return -EINVAL;
2828 memset(parm,0,sizeof(*parm));
2829 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2830 bttv_tvnorms[btv->tvnorm].name);
2831 parm->parm.capture.timeperframe = s.frameperiod;
2832 return 0;
2833 }
2834
2835 case VIDIOC_G_PRIORITY:
2836 {
2837 enum v4l2_priority *p = arg;
2838
2839 *p = v4l2_prio_max(&btv->prio);
2840 return 0;
2841 }
2842 case VIDIOC_S_PRIORITY:
2843 {
2844 enum v4l2_priority *prio = arg;
2845
2846 return v4l2_prio_change(&btv->prio, &fh->prio, *prio);
2847 }
2848
2849 case VIDIOC_ENUMSTD:
2850 case VIDIOC_G_STD:
2851 case VIDIOC_S_STD:
2852 case VIDIOC_ENUMINPUT:
2853 case VIDIOC_G_INPUT:
2854 case VIDIOC_S_INPUT:
2855 case VIDIOC_G_TUNER:
2856 case VIDIOC_S_TUNER:
2857 case VIDIOC_G_FREQUENCY:
2858 case VIDIOC_S_FREQUENCY:
2859 return bttv_common_ioctls(btv,cmd,arg);
2860
2861 default:
2862 return -ENOIOCTLCMD;
2863 }
2864 return 0;
2865
2866 fh_unlock_and_return:
2867 up(&fh->cap.lock);
2868 return retval;
2869}
2870
2871static int bttv_ioctl(struct inode *inode, struct file *file,
2872 unsigned int cmd, unsigned long arg)
2873{
2874 struct bttv_fh *fh = file->private_data;
2875
2876 switch (cmd) {
2877 case BTTV_VBISIZE:
2878 bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2879 return fh->lines * 2 * 2048;
2880 default:
2881 return video_usercopy(inode, file, cmd, arg, bttv_do_ioctl);
2882 }
2883}
2884
2885static ssize_t bttv_read(struct file *file, char __user *data,
2886 size_t count, loff_t *ppos)
2887{
2888 struct bttv_fh *fh = file->private_data;
2889 int retval = 0;
2890
2891 if (fh->btv->errors)
2892 bttv_reinit_bt848(fh->btv);
2893 dprintk("bttv%d: read count=%d type=%s\n",
2894 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
2895
2896 switch (fh->type) {
2897 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2898 if (locked_btres(fh->btv,RESOURCE_VIDEO))
2899 return -EBUSY;
2900 retval = videobuf_read_one(&fh->cap, data, count, ppos,
2901 file->f_flags & O_NONBLOCK);
2902 break;
2903 case V4L2_BUF_TYPE_VBI_CAPTURE:
2904 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
2905 return -EBUSY;
2906 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2907 file->f_flags & O_NONBLOCK);
2908 break;
2909 default:
2910 BUG();
2911 }
2912 return retval;
2913}
2914
2915static unsigned int bttv_poll(struct file *file, poll_table *wait)
2916{
2917 struct bttv_fh *fh = file->private_data;
2918 struct bttv_buffer *buf;
2919 enum v4l2_field field;
2920
2921 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2922 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
2923 return POLLERR;
2924 return videobuf_poll_stream(file, &fh->vbi, wait);
2925 }
2926
2927 if (check_btres(fh,RESOURCE_VIDEO)) {
2928 /* streaming capture */
2929 if (list_empty(&fh->cap.stream))
2930 return POLLERR;
2931 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
2932 } else {
2933 /* read() capture */
2934 down(&fh->cap.lock);
2935 if (NULL == fh->cap.read_buf) {
2936 /* need to capture a new frame */
2937 if (locked_btres(fh->btv,RESOURCE_VIDEO)) {
2938 up(&fh->cap.lock);
2939 return POLLERR;
2940 }
2941 fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
2942 if (NULL == fh->cap.read_buf) {
2943 up(&fh->cap.lock);
2944 return POLLERR;
2945 }
2946 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
2947 field = videobuf_next_field(&fh->cap);
2948 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
2949 up(&fh->cap.lock);
2950 return POLLERR;
2951 }
2952 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
2953 fh->cap.read_off = 0;
2954 }
2955 up(&fh->cap.lock);
2956 buf = (struct bttv_buffer*)fh->cap.read_buf;
2957 }
2958
2959 poll_wait(file, &buf->vb.done, wait);
2960 if (buf->vb.state == STATE_DONE ||
2961 buf->vb.state == STATE_ERROR)
2962 return POLLIN|POLLRDNORM;
2963 return 0;
2964}
2965
2966static int bttv_open(struct inode *inode, struct file *file)
2967{
2968 int minor = iminor(inode);
2969 struct bttv *btv = NULL;
2970 struct bttv_fh *fh;
2971 enum v4l2_buf_type type = 0;
2972 unsigned int i;
2973
2974 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
2975
2976 for (i = 0; i < bttv_num; i++) {
2977 if (bttvs[i].video_dev &&
2978 bttvs[i].video_dev->minor == minor) {
2979 btv = &bttvs[i];
2980 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2981 break;
2982 }
2983 if (bttvs[i].vbi_dev &&
2984 bttvs[i].vbi_dev->minor == minor) {
2985 btv = &bttvs[i];
2986 type = V4L2_BUF_TYPE_VBI_CAPTURE;
2987 break;
2988 }
2989 }
2990 if (NULL == btv)
2991 return -ENODEV;
2992
2993 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
2994 btv->c.nr,v4l2_type_names[type]);
2995
2996 /* allocate per filehandle data */
2997 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
2998 if (NULL == fh)
2999 return -ENOMEM;
3000 file->private_data = fh;
3001 *fh = btv->init;
3002 fh->type = type;
3003 fh->ov.setup_ok = 0;
3004 v4l2_prio_open(&btv->prio,&fh->prio);
3005
3006 videobuf_queue_init(&fh->cap, &bttv_video_qops,
3007 btv->c.pci, &btv->s_lock,
3008 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3009 V4L2_FIELD_INTERLACED,
3010 sizeof(struct bttv_buffer),
3011 fh);
3012 videobuf_queue_init(&fh->vbi, &bttv_vbi_qops,
3013 btv->c.pci, &btv->s_lock,
3014 V4L2_BUF_TYPE_VBI_CAPTURE,
3015 V4L2_FIELD_SEQ_TB,
3016 sizeof(struct bttv_buffer),
3017 fh);
3018 i2c_vidiocschan(btv);
3019
3020 btv->users++;
3021 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
3022 bttv_vbi_setlines(fh,btv,16);
3023 bttv_field_count(btv);
3024 return 0;
3025}
3026
3027static int bttv_release(struct inode *inode, struct file *file)
3028{
3029 struct bttv_fh *fh = file->private_data;
3030 struct bttv *btv = fh->btv;
3031
3032 /* turn off overlay */
3033 if (check_btres(fh, RESOURCE_OVERLAY))
3034 bttv_switch_overlay(btv,fh,NULL);
3035
3036 /* stop video capture */
3037 if (check_btres(fh, RESOURCE_VIDEO)) {
3038 videobuf_streamoff(&fh->cap);
3039 free_btres(btv,fh,RESOURCE_VIDEO);
3040 }
3041 if (fh->cap.read_buf) {
3042 buffer_release(&fh->cap,fh->cap.read_buf);
3043 kfree(fh->cap.read_buf);
3044 }
3045
3046 /* stop vbi capture */
3047 if (check_btres(fh, RESOURCE_VBI)) {
3048 if (fh->vbi.streaming)
3049 videobuf_streamoff(&fh->vbi);
3050 if (fh->vbi.reading)
3051 videobuf_read_stop(&fh->vbi);
3052 free_btres(btv,fh,RESOURCE_VBI);
3053 }
3054
3055 /* free stuff */
3056 videobuf_mmap_free(&fh->cap);
3057 videobuf_mmap_free(&fh->vbi);
3058 v4l2_prio_close(&btv->prio,&fh->prio);
3059 file->private_data = NULL;
3060 kfree(fh);
3061
3062 btv->users--;
3063 bttv_field_count(btv);
3064 return 0;
3065}
3066
3067static int
3068bttv_mmap(struct file *file, struct vm_area_struct *vma)
3069{
3070 struct bttv_fh *fh = file->private_data;
3071
3072 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3073 fh->btv->c.nr, v4l2_type_names[fh->type],
3074 vma->vm_start, vma->vm_end - vma->vm_start);
3075 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3076}
3077
3078static struct file_operations bttv_fops =
3079{
3080 .owner = THIS_MODULE,
3081 .open = bttv_open,
3082 .release = bttv_release,
3083 .ioctl = bttv_ioctl,
3084 .llseek = no_llseek,
3085 .read = bttv_read,
3086 .mmap = bttv_mmap,
3087 .poll = bttv_poll,
3088};
3089
3090static struct video_device bttv_video_template =
3091{
3092 .name = "UNSET",
4dcef524 3093 .type = VID_TYPE_CAPTURE|VID_TYPE_TUNER|
1da177e4
LT		 3094 VID_TYPE_CLIPPING|VID_TYPE_SCALES,
3095 .hardware = VID_HARDWARE_BT848,
3096 .fops = &bttv_fops,
3097 .minor = -1,
3098};
3099
3100static struct video_device bttv_vbi_template =
3101{
3102 .name = "bt848/878 vbi",
3103 .type = VID_TYPE_TUNER|VID_TYPE_TELETEXT,
3104 .hardware = VID_HARDWARE_BT848,
3105 .fops = &bttv_fops,
3106 .minor = -1,
3107};
3108
3109/* ----------------------------------------------------------------------- */
3110/* radio interface */
3111
3112static int radio_open(struct inode *inode, struct file *file)
3113{
3114 int minor = iminor(inode);
3115 struct bttv *btv = NULL;
3116 unsigned int i;
3117
3118 dprintk("bttv: open minor=%d\n",minor);
3119
3120 for (i = 0; i < bttv_num; i++) {
3121 if (bttvs[i].radio_dev->minor == minor) {
3122 btv = &bttvs[i];
3123 break;
3124 }
3125 }
3126 if (NULL == btv)
3127 return -ENODEV;
3128
3129 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3130 down(&btv->lock);
24a70fdc 3131
1da177e4 3132 btv->radio_user++;
24a70fdc 3133
1da177e4
LT		 3134 file->private_data = btv;
3135
24a70fdc 3136 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,&btv->tuner_type);
1da177e4
LT		 3137 audio_mux(btv,AUDIO_RADIO);
3138
3139 up(&btv->lock);
3140 return 0;
3141}
3142
3143static int radio_release(struct inode *inode, struct file *file)
3144{
24a70fdc
MCC		 3145 struct bttv *btv = file->private_data;
3146 struct rds_command cmd;
1da177e4
LT		 3147
3148 btv->radio_user--;
24a70fdc
MCC		 3149
3150 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3151
1da177e4
LT		 3152 return 0;
3153}
3154
3155static int radio_do_ioctl(struct inode *inode, struct file *file,
3156 unsigned int cmd, void *arg)
3157{
3158 struct bttv *btv = file->private_data;
3159
3160 switch (cmd) {
3161 case VIDIOCGCAP:
3162 {
3163 struct video_capability *cap = arg;
3164
3165 memset(cap,0,sizeof(*cap));
3166 strcpy(cap->name,btv->radio_dev->name);
3167 cap->type = VID_TYPE_TUNER;
3168 cap->channels = 1;
3169 cap->audios = 1;
3170 return 0;
3171 }
3172
3173 case VIDIOCGTUNER:
3174 {
3175 struct video_tuner *v = arg;
3176
3177 if(v->tuner)
3178 return -EINVAL;
3179 memset(v,0,sizeof(*v));
3180 strcpy(v->name, "Radio");
1da177e4
LT		 3181 bttv_call_i2c_clients(btv,cmd,v);
3182 return 0;
3183 }
3184 case VIDIOCSTUNER:
3185 /* nothing to do */
3186 return 0;
3187
3188 case BTTV_VERSION:
3189 case VIDIOCGFREQ:
3190 case VIDIOCSFREQ:
3191 case VIDIOCGAUDIO:
3192 case VIDIOCSAUDIO:
3193 return bttv_common_ioctls(btv,cmd,arg);
3194
3195 default:
3196 return -ENOIOCTLCMD;
3197 }
3198 return 0;
3199}
3200
3201static int radio_ioctl(struct inode *inode, struct file *file,
3202 unsigned int cmd, unsigned long arg)
3203{
3204 return video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
3205}
3206
24a70fdc
MCC		 3207static ssize_t radio_read(struct file *file, char __user *data,
3208 size_t count, loff_t *ppos)
3209{
3210 struct bttv *btv = file->private_data;
3211 struct rds_command cmd;
3212 cmd.block_count = count/3;
3213 cmd.buffer = data;
3214 cmd.instance = file;
3215 cmd.result = -ENODEV;
3216
3217 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3218
3219 return cmd.result;
3220}
3221
3222static unsigned int radio_poll(struct file *file, poll_table *wait)
3223{
3224 struct bttv *btv = file->private_data;
3225 struct rds_command cmd;
3226 cmd.instance = file;
3227 cmd.event_list = wait;
3228 cmd.result = -ENODEV;
3229 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3230
3231 return cmd.result;
3232}
3233
1da177e4
LT		 3234static struct file_operations radio_fops =
3235{
3236 .owner = THIS_MODULE,
3237 .open = radio_open,
24a70fdc 3238 .read = radio_read,
1da177e4
LT		 3239 .release = radio_release,
3240 .ioctl = radio_ioctl,
3241 .llseek = no_llseek,
24a70fdc 3242 .poll = radio_poll,
1da177e4
LT		 3243};
3244
3245static struct video_device radio_template =
3246{
3247 .name = "bt848/878 radio",
3248 .type = VID_TYPE_TUNER,
3249 .hardware = VID_HARDWARE_BT848,
3250 .fops = &radio_fops,
3251 .minor = -1,
3252};
3253
3254/* ----------------------------------------------------------------------- */
3255/* some debug code */
3256
408b664a 3257static int bttv_risc_decode(u32 risc)
1da177e4
LT		 3258{
3259 static char *instr[16] = {
3260 [ BT848_RISC_WRITE >> 28 ] = "write",
3261 [ BT848_RISC_SKIP >> 28 ] = "skip",
3262 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3263 [ BT848_RISC_JUMP >> 28 ] = "jump",
3264 [ BT848_RISC_SYNC >> 28 ] = "sync",
3265 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3266 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3267 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3268 };
3269 static int incr[16] = {
3270 [ BT848_RISC_WRITE >> 28 ] = 2,
3271 [ BT848_RISC_JUMP >> 28 ] = 2,
3272 [ BT848_RISC_SYNC >> 28 ] = 2,
3273 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3274 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3275 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3276 };
3277 static char *bits[] = {
3278 "be0", "be1", "be2", "be3/resync",
3279 "set0", "set1", "set2", "set3",
3280 "clr0", "clr1", "clr2", "clr3",
3281 "irq", "res", "eol", "sol",
3282 };
3283 int i;
3284
3285 printk("0x%08x [ %s", risc,
3286 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3287 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3288 if (risc & (1 << (i + 12)))
3289 printk(" %s",bits[i]);
3290 printk(" count=%d ]\n", risc & 0xfff);
3291 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3292}
3293
408b664a
AB		 3294static void bttv_risc_disasm(struct bttv *btv,
3295 struct btcx_riscmem *risc)
1da177e4
LT		 3296{
3297 unsigned int i,j,n;
3298
3299 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3300 btv->c.name, risc->cpu, (unsigned long)risc->dma);
3301 for (i = 0; i < (risc->size >> 2); i += n) {
3302 printk("%s: 0x%lx: ", btv->c.name,
3303 (unsigned long)(risc->dma + (i<<2)));
3304 n = bttv_risc_decode(risc->cpu[i]);
3305 for (j = 1; j < n; j++)
3306 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3307 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3308 risc->cpu[i+j], j);
3309 if (0 == risc->cpu[i])
3310 break;
3311 }
3312}
3313
3314static void bttv_print_riscaddr(struct bttv *btv)
3315{
3316 printk(" main: %08Lx\n",
3317 (unsigned long long)btv->main.dma);
3318 printk(" vbi : o=%08Lx e=%08Lx\n",
3319 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3320 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3321 printk(" cap : o=%08Lx e=%08Lx\n",
3322 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3323 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3324 printk(" scr : o=%08Lx e=%08Lx\n",
3325 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3326 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3327 bttv_risc_disasm(btv, &btv->main);
3328}
3329
3330/* ----------------------------------------------------------------------- */
3331/* irq handler */
3332
3333static char *irq_name[] = {
3334 "FMTCHG", // format change detected (525 vs. 625)
3335 "VSYNC", // vertical sync (new field)
3336 "HSYNC", // horizontal sync
3337 "OFLOW", // chroma/luma AGC overflow
3338 "HLOCK", // horizontal lock changed
3339 "VPRES", // video presence changed
3340 "6", "7",
3341 "I2CDONE", // hw irc operation finished
3342 "GPINT", // gpio port triggered irq
3343 "10",
3344 "RISCI", // risc instruction triggered irq
3345 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3346 "FTRGT", // pixel data fifo overrun
3347 "FDSR", // fifo data stream resyncronisation
3348 "PPERR", // parity error (data transfer)
3349 "RIPERR", // parity error (read risc instructions)
3350 "PABORT", // pci abort
3351 "OCERR", // risc instruction error
3352 "SCERR", // syncronisation error
3353};
3354
3355static void bttv_print_irqbits(u32 print, u32 mark)
3356{
3357 unsigned int i;
3358
3359 printk("bits:");
3360 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3361 if (print & (1 << i))
3362 printk(" %s",irq_name[i]);
3363 if (mark & (1 << i))
3364 printk("*");
3365 }
3366}
3367
3368static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3369{
3370 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3371 btv->c.nr,
3372 (unsigned long)btv->main.dma,
3373 (unsigned long)btv->main.cpu[RISC_SLOT_O_VBI+1],
3374 (unsigned long)btv->main.cpu[RISC_SLOT_O_FIELD+1],
3375 (unsigned long)rc);
3376
3377 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3378 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3379 "Ok, then this is harmless, don't worry ;)\n",
3380 btv->c.nr);
3381 return;
3382 }
3383 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3384 btv->c.nr);
3385 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3386 btv->c.nr);
3387 dump_stack();
3388}
3389
3390static int
3391bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3392{
3393 struct bttv_buffer *item;
3394
3395 memset(set,0,sizeof(*set));
3396
3397 /* capture request ? */
3398 if (!list_empty(&btv->capture)) {
3399 set->frame_irq = 1;
3400 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3401 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3402 set->top = item;
3403 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3404 set->bottom = item;
3405
3406 /* capture request for other field ? */
3407 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3408 (item->vb.queue.next != &btv->capture)) {
3409 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3410 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3411 if (NULL == set->top &&
3412 V4L2_FIELD_TOP == item->vb.field) {
3413 set->top = item;
3414 }
3415 if (NULL == set->bottom &&
3416 V4L2_FIELD_BOTTOM == item->vb.field) {
3417 set->bottom = item;
3418 }
3419 if (NULL != set->top && NULL != set->bottom)
3420 set->top_irq = 2;
3421 }
3422 }
3423 }
3424
3425 /* screen overlay ? */
3426 if (NULL != btv->screen) {
3427 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3428 if (NULL == set->top && NULL == set->bottom) {
3429 set->top = btv->screen;
3430 set->bottom = btv->screen;
3431 }
3432 } else {
3433 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3434 NULL == set->top) {
3435 set->top = btv->screen;
3436 }
3437 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3438 NULL == set->bottom) {
3439 set->bottom = btv->screen;
3440 }
3441 }
3442 }
3443
3444 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3445 btv->c.nr,set->top, set->bottom,
3446 btv->screen,set->frame_irq,set->top_irq);
3447 return 0;
3448}
3449
3450static void
3451bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3452 struct bttv_buffer_set *curr, unsigned int state)
3453{
3454 struct timeval ts;
3455
3456 do_gettimeofday(&ts);
3457
3458 if (wakeup->top == wakeup->bottom) {
3459 if (NULL != wakeup->top && curr->top != wakeup->top) {
3460 if (irq_debug > 1)
3461 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3462 wakeup->top->vb.ts = ts;
3463 wakeup->top->vb.field_count = btv->field_count;
3464 wakeup->top->vb.state = state;
3465 wake_up(&wakeup->top->vb.done);
3466 }
3467 } else {
3468 if (NULL != wakeup->top && curr->top != wakeup->top) {
3469 if (irq_debug > 1)
3470 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3471 wakeup->top->vb.ts = ts;
3472 wakeup->top->vb.field_count = btv->field_count;
3473 wakeup->top->vb.state = state;
3474 wake_up(&wakeup->top->vb.done);
3475 }
3476 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3477 if (irq_debug > 1)
3478 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3479 wakeup->bottom->vb.ts = ts;
3480 wakeup->bottom->vb.field_count = btv->field_count;
3481 wakeup->bottom->vb.state = state;
3482 wake_up(&wakeup->bottom->vb.done);
3483 }
3484 }
3485}
3486
3487static void
3488bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3489 unsigned int state)
3490{
3491 struct timeval ts;
3492
3493 if (NULL == wakeup)
3494 return;
3495
3496 do_gettimeofday(&ts);
3497 wakeup->vb.ts = ts;
3498 wakeup->vb.field_count = btv->field_count;
3499 wakeup->vb.state = state;
3500 wake_up(&wakeup->vb.done);
3501}
3502
3503static void bttv_irq_timeout(unsigned long data)
3504{
3505 struct bttv *btv = (struct bttv *)data;
3506 struct bttv_buffer_set old,new;
3507 struct bttv_buffer *ovbi;
3508 struct bttv_buffer *item;
3509 unsigned long flags;
3510
3511 if (bttv_verbose) {
3512 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3513 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3514 btread(BT848_RISC_COUNT));
3515 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3516 printk("\n");
3517 }
3518
3519 spin_lock_irqsave(&btv->s_lock,flags);
3520
3521 /* deactivate stuff */
3522 memset(&new,0,sizeof(new));
3523 old = btv->curr;
3524 ovbi = btv->cvbi;
3525 btv->curr = new;
3526 btv->cvbi = NULL;
3527 btv->loop_irq = 0;
3528 bttv_buffer_activate_video(btv, &new);
3529 bttv_buffer_activate_vbi(btv, NULL);
3530 bttv_set_dma(btv, 0);
3531
3532 /* wake up */
3533 bttv_irq_wakeup_video(btv, &old, &new, STATE_ERROR);
3534 bttv_irq_wakeup_vbi(btv, ovbi, STATE_ERROR);
3535
3536 /* cancel all outstanding capture / vbi requests */
3537 while (!list_empty(&btv->capture)) {
3538 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3539 list_del(&item->vb.queue);
3540 item->vb.state = STATE_ERROR;
3541 wake_up(&item->vb.done);
3542 }
3543 while (!list_empty(&btv->vcapture)) {
3544 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3545 list_del(&item->vb.queue);
3546 item->vb.state = STATE_ERROR;
3547 wake_up(&item->vb.done);
3548 }
3549
3550 btv->errors++;
3551 spin_unlock_irqrestore(&btv->s_lock,flags);
3552}
3553
3554static void
3555bttv_irq_wakeup_top(struct bttv *btv)
3556{
3557 struct bttv_buffer *wakeup = btv->curr.top;
3558
3559 if (NULL == wakeup)
3560 return;
3561
3562 spin_lock(&btv->s_lock);
3563 btv->curr.top_irq = 0;
3564 btv->curr.top = NULL;
3565 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3566
3567 do_gettimeofday(&wakeup->vb.ts);
3568 wakeup->vb.field_count = btv->field_count;
3569 wakeup->vb.state = STATE_DONE;
3570 wake_up(&wakeup->vb.done);
3571 spin_unlock(&btv->s_lock);
3572}
3573
3574static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3575{
3576 if (rc < risc->dma)
3577 return 0;
3578 if (rc > risc->dma + risc->size)
3579 return 0;
3580 return 1;
3581}
3582
3583static void
3584bttv_irq_switch_video(struct bttv *btv)
3585{
3586 struct bttv_buffer_set new;
3587 struct bttv_buffer_set old;
3588 dma_addr_t rc;
3589
3590 spin_lock(&btv->s_lock);
3591
3592 /* new buffer set */
3593 bttv_irq_next_video(btv, &new);
3594 rc = btread(BT848_RISC_COUNT);
3595 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3596 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3597 btv->framedrop++;
3598 if (debug_latency)
3599 bttv_irq_debug_low_latency(btv, rc);
3600 spin_unlock(&btv->s_lock);
3601 return;
3602 }
3603
3604 /* switch over */
3605 old = btv->curr;
3606 btv->curr = new;
3607 btv->loop_irq &= ~1;
3608 bttv_buffer_activate_video(btv, &new);
3609 bttv_set_dma(btv, 0);
3610
3611 /* switch input */
3612 if (UNSET != btv->new_input) {
3613 video_mux(btv,btv->new_input);
3614 btv->new_input = UNSET;
3615 }
3616
3617 /* wake up finished buffers */
3618 bttv_irq_wakeup_video(btv, &old, &new, STATE_DONE);
3619 spin_unlock(&btv->s_lock);
3620}
3621
3622static void
3623bttv_irq_switch_vbi(struct bttv *btv)
3624{
3625 struct bttv_buffer *new = NULL;
3626 struct bttv_buffer *old;
3627 u32 rc;
3628
3629 spin_lock(&btv->s_lock);
3630
3631 if (!list_empty(&btv->vcapture))
3632 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3633 old = btv->cvbi;
3634
3635 rc = btread(BT848_RISC_COUNT);
3636 if (NULL != old && (is_active(&old->top, rc) ||
3637 is_active(&old->bottom, rc))) {
3638 btv->framedrop++;
3639 if (debug_latency)
3640 bttv_irq_debug_low_latency(btv, rc);
3641 spin_unlock(&btv->s_lock);
3642 return;
3643 }
3644
3645 /* switch */
3646 btv->cvbi = new;
3647 btv->loop_irq &= ~4;
3648 bttv_buffer_activate_vbi(btv, new);
3649 bttv_set_dma(btv, 0);
3650
3651 bttv_irq_wakeup_vbi(btv, old, STATE_DONE);
3652 spin_unlock(&btv->s_lock);
3653}
3654
3655static irqreturn_t bttv_irq(int irq, void *dev_id, struct pt_regs * regs)
3656{
3657 u32 stat,astat;
3658 u32 dstat;
3659 int count;
3660 struct bttv *btv;
3661 int handled = 0;
3662
3663 btv=(struct bttv *)dev_id;
3664 count=0;
3665 while (1) {
3666 /* get/clear interrupt status bits */
3667 stat=btread(BT848_INT_STAT);
3668 astat=stat&btread(BT848_INT_MASK);
3669 if (!astat)
3670 break;
3671 handled = 1;
3672 btwrite(stat,BT848_INT_STAT);
3673
3674 /* get device status bits */
3675 dstat=btread(BT848_DSTATUS);
3676
3677 if (irq_debug) {
3678 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
3679 "riscs=%x, riscc=%08x, ",
3680 btv->c.nr, count, btv->field_count,
3681 stat>>28, btread(BT848_RISC_COUNT));
3682 bttv_print_irqbits(stat,astat);
3683 if (stat & BT848_INT_HLOCK)
3684 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
3685 ? "yes" : "no");
3686 if (stat & BT848_INT_VPRES)
3687 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
3688 ? "yes" : "no");
3689 if (stat & BT848_INT_FMTCHG)
3690 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
3691 ? "625" : "525");
3692 printk("\n");
3693 }
3694
3695 if (astat&BT848_INT_VSYNC)
3696 btv->field_count++;
3697
3698 if (astat & BT848_INT_GPINT) {
3699 wake_up(&btv->gpioq);
3700 bttv_gpio_irq(&btv->c);
3701 }
3702
3703 if (astat & BT848_INT_I2CDONE) {
3704 btv->i2c_done = stat;
3705 wake_up(&btv->i2c_queue);
3706 }
3707
3708 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
3709 bttv_irq_switch_vbi(btv);
3710
3711 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
3712 bttv_irq_wakeup_top(btv);
3713
3714 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
3715 bttv_irq_switch_video(btv);
3716
3717 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
3718 audio_mux(btv, -1);
3719
3720 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3721 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
3722 (astat & BT848_INT_SCERR) ? "SCERR" : "",
3723 (astat & BT848_INT_OCERR) ? "OCERR" : "",
3724 btread(BT848_RISC_COUNT));
3725 bttv_print_irqbits(stat,astat);
3726 printk("\n");
3727 if (bttv_debug)
3728 bttv_print_riscaddr(btv);
3729 }
3730 if (fdsr && astat & BT848_INT_FDSR) {
3731 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
3732 btv->c.nr,btread(BT848_RISC_COUNT));
3733 if (bttv_debug)
3734 bttv_print_riscaddr(btv);
3735 }
3736
3737 count++;
3738 if (count > 4) {
3739 btwrite(0, BT848_INT_MASK);
3740 printk(KERN_ERR
3741 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
3742 bttv_print_irqbits(stat,astat);
3743 printk("]\n");
3744 }
3745 }
3746 btv->irq_total++;
3747 if (handled)
3748 btv->irq_me++;
3749 return IRQ_RETVAL(handled);
3750}
3751
3752
3753/* ----------------------------------------------------------------------- */
3754/* initialitation */
3755
3756static struct video_device *vdev_init(struct bttv *btv,
3757 struct video_device *template,
3758 char *type)
3759{
3760 struct video_device *vfd;
3761
3762 vfd = video_device_alloc();
3763 if (NULL == vfd)
3764 return NULL;
3765 *vfd = *template;
3766 vfd->minor = -1;
3767 vfd->dev = &btv->c.pci->dev;
3768 vfd->release = video_device_release;
3769 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3770 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3771 type, bttv_tvcards[btv->c.type].name);
3772 return vfd;
3773}
3774
3775static void bttv_unregister_video(struct bttv *btv)
3776{
3777 if (btv->video_dev) {
3778 if (-1 != btv->video_dev->minor)
3779 video_unregister_device(btv->video_dev);
3780 else
3781 video_device_release(btv->video_dev);
3782 btv->video_dev = NULL;
3783 }
3784 if (btv->vbi_dev) {
3785 if (-1 != btv->vbi_dev->minor)
3786 video_unregister_device(btv->vbi_dev);
3787 else
3788 video_device_release(btv->vbi_dev);
3789 btv->vbi_dev = NULL;
3790 }
3791 if (btv->radio_dev) {
3792 if (-1 != btv->radio_dev->minor)
3793 video_unregister_device(btv->radio_dev);
3794 else
3795 video_device_release(btv->radio_dev);
3796 btv->radio_dev = NULL;
3797 }
3798}
3799
3800/* register video4linux devices */
3801static int __devinit bttv_register_video(struct bttv *btv)
3802{
4dcef524
MCC		 3803 if (no_overlay <= 0) {
3804 bttv_video_template.type |= VID_TYPE_OVERLAY;
3805 } else {
3806 printk("bttv: Overlay support disabled.\n");
3807 }
3808
1da177e4
LT		 3809 /* video */
3810 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
3811 if (NULL == btv->video_dev)
3812 goto err;
3813 if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
3814 goto err;
3815 printk(KERN_INFO "bttv%d: registered device video%d\n",
3816 btv->c.nr,btv->video_dev->minor & 0x1f);
3817 video_device_create_file(btv->video_dev, &class_device_attr_card);
3818
3819 /* vbi */
3820 btv->vbi_dev = vdev_init(btv, &bttv_vbi_template, "vbi");
3821 if (NULL == btv->vbi_dev)
3822 goto err;
3823 if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
3824 goto err;
3825 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
3826 btv->c.nr,btv->vbi_dev->minor & 0x1f);
3827
3828 if (!btv->has_radio)
3829 return 0;
3830 /* radio */
3831 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
3832 if (NULL == btv->radio_dev)
3833 goto err;
3834 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
3835 goto err;
3836 printk(KERN_INFO "bttv%d: registered device radio%d\n",
3837 btv->c.nr,btv->radio_dev->minor & 0x1f);
3838
3839 /* all done */
3840 return 0;
3841
3842 err:
3843 bttv_unregister_video(btv);
3844 return -1;
3845}
3846
3847
3848/* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3849/* response on cards with no firmware is not enabled by OF */
3850static void pci_set_command(struct pci_dev *dev)
3851{
3852#if defined(__powerpc__)
3853 unsigned int cmd;
3854
3855 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3856 cmd = (cmd | PCI_COMMAND_MEMORY );
3857 pci_write_config_dword(dev, PCI_COMMAND, cmd);
3858#endif
3859}
3860
3861static int __devinit bttv_probe(struct pci_dev *dev,
3862 const struct pci_device_id *pci_id)
3863{
3864 int result;
3865 unsigned char lat;
3866 struct bttv *btv;
3867
3868 if (bttv_num == BTTV_MAX)
3869 return -ENOMEM;
3870 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
3871 btv=&bttvs[bttv_num];
3872 memset(btv,0,sizeof(*btv));
3873 btv->c.nr = bttv_num;
3874 sprintf(btv->c.name,"bttv%d",btv->c.nr);
3875
3876 /* initialize structs / fill in defaults */
3877 init_MUTEX(&btv->lock);
3878 init_MUTEX(&btv->reslock);
3879 spin_lock_init(&btv->s_lock);
3880 spin_lock_init(&btv->gpio_lock);
3881 init_waitqueue_head(&btv->gpioq);
3882 init_waitqueue_head(&btv->i2c_queue);
3883 INIT_LIST_HEAD(&btv->c.subs);
3884 INIT_LIST_HEAD(&btv->capture);
3885 INIT_LIST_HEAD(&btv->vcapture);
3886 v4l2_prio_init(&btv->prio);
3887
3888 init_timer(&btv->timeout);
3889 btv->timeout.function = bttv_irq_timeout;
3890 btv->timeout.data = (unsigned long)btv;
3891
7c08fb02
MK		 3892 btv->i2c_rc = -1;
3893 btv->tuner_type = UNSET;
3894 btv->pinnacle_id = UNSET;
1da177e4 3895 btv->new_input = UNSET;
1da177e4
LT		 3896 btv->has_radio=radio[btv->c.nr];
3897
3898 /* pci stuff (init, get irq/mmio, ... */
3899 btv->c.pci = dev;
7c08fb02 3900 btv->id = dev->device;
1da177e4 3901 if (pci_enable_device(dev)) {
7c08fb02 3902 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
1da177e4
LT		 3903 btv->c.nr);
3904 return -EIO;
3905 }
fa9846a8 3906 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
1da177e4
LT		 3907 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
3908 btv->c.nr);
3909 return -EIO;
3910 }
3911 if (!request_mem_region(pci_resource_start(dev,0),
3912 pci_resource_len(dev,0),
3913 btv->c.name)) {
3914 printk(KERN_WARNING "bttv%d: can't request iomem (0x%lx).\n",
3915 btv->c.nr, pci_resource_start(dev,0));
3916 return -EBUSY;
3917 }
3918 pci_set_master(dev);
3919 pci_set_command(dev);
3920 pci_set_drvdata(dev,btv);
1da177e4
LT		 3921
3922 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
3923 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
3924 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
3925 bttv_num,btv->id, btv->revision, pci_name(dev));
3926 printk("irq: %d, latency: %d, mmio: 0x%lx\n",
3927 btv->c.pci->irq, lat, pci_resource_start(dev,0));
3928 schedule();
3929
3930 btv->bt848_mmio=ioremap(pci_resource_start(dev,0), 0x1000);
3931 if (NULL == ioremap(pci_resource_start(dev,0), 0x1000)) {
3932 printk("bttv%d: ioremap() failed\n", btv->c.nr);
3933 result = -EIO;
3934 goto fail1;
3935 }
3936
3937 /* identify card */
3938 bttv_idcard(btv);
3939
3940 /* disable irqs, register irq handler */
3941 btwrite(0, BT848_INT_MASK);
3942 result = request_irq(btv->c.pci->irq, bttv_irq,
3943 SA_SHIRQ | SA_INTERRUPT,btv->c.name,(void *)btv);
3944 if (result < 0) {
3945 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
3946 bttv_num,btv->c.pci->irq);
3947 goto fail1;
3948 }
3949
3950 if (0 != bttv_handle_chipset(btv)) {
3951 result = -EIO;
3952 goto fail2;
3953 }
3954
3955 /* init options from insmod args */
3956 btv->opt_combfilter = combfilter;
3957 btv->opt_lumafilter = lumafilter;
3958 btv->opt_automute = automute;
3959 btv->opt_chroma_agc = chroma_agc;
3960 btv->opt_adc_crush = adc_crush;
3961 btv->opt_vcr_hack = vcr_hack;
3962 btv->opt_whitecrush_upper = whitecrush_upper;
3963 btv->opt_whitecrush_lower = whitecrush_lower;
060d3027
MCC		 3964 btv->opt_uv_ratio = uv_ratio;
3965 btv->opt_full_luma_range = full_luma_range;
3966 btv->opt_coring = coring;
1da177e4
LT		 3967
3968 /* fill struct bttv with some useful defaults */
3969 btv->init.btv = btv;
3970 btv->init.ov.w.width = 320;
3971 btv->init.ov.w.height = 240;
3972 btv->init.fmt = format_by_palette(VIDEO_PALETTE_RGB24);
3973 btv->init.width = 320;
3974 btv->init.height = 240;
3975 btv->init.lines = 16;
3976 btv->input = 0;
3977
3978 /* initialize hardware */
3979 if (bttv_gpio)
3980 bttv_gpio_tracking(btv,"pre-init");
3981
3982 bttv_risc_init_main(btv);
3983 init_bt848(btv);
3984
3985 /* gpio */
3986 btwrite(0x00, BT848_GPIO_REG_INP);
3987 btwrite(0x00, BT848_GPIO_OUT_EN);
3988 if (bttv_verbose)
3989 bttv_gpio_tracking(btv,"init");
3990
3991 /* needs to be done before i2c is registered */
3992 bttv_init_card1(btv);
3993
3994 /* register i2c + gpio */
3995 init_bttv_i2c(btv);
3996
3997 /* some card-specific stuff (needs working i2c) */
3998 bttv_init_card2(btv);
3999 init_irqreg(btv);
4000
4001 /* register video4linux + input */
4002 if (!bttv_tvcards[btv->c.type].no_video) {
4003 bttv_register_video(btv);
4004 bt848_bright(btv,32768);
4005 bt848_contrast(btv,32768);
4006 bt848_hue(btv,32768);
4007 bt848_sat(btv,32768);
4008 audio_mux(btv,AUDIO_MUTE);
4009 set_input(btv,0);
4010 }
4011
4012 /* add subdevices */
4013 if (btv->has_remote)
4014 bttv_sub_add_device(&btv->c, "remote");
4015 if (bttv_tvcards[btv->c.type].has_dvb)
4016 bttv_sub_add_device(&btv->c, "dvb");
4017
4018 /* everything is fine */
4019 bttv_num++;
4020 return 0;
4021
4022 fail2:
4023 free_irq(btv->c.pci->irq,btv);
4024
4025 fail1:
4026 if (btv->bt848_mmio)
4027 iounmap(btv->bt848_mmio);
4028 release_mem_region(pci_resource_start(btv->c.pci,0),
4029 pci_resource_len(btv->c.pci,0));
4030 pci_set_drvdata(dev,NULL);
4031 return result;
4032}
4033
4034static void __devexit bttv_remove(struct pci_dev *pci_dev)
4035{
4036 struct bttv *btv = pci_get_drvdata(pci_dev);
4037
4038 if (bttv_verbose)
4039 printk("bttv%d: unloading\n",btv->c.nr);
4040
4041 /* shutdown everything (DMA+IRQs) */
4042 btand(~15, BT848_GPIO_DMA_CTL);
4043 btwrite(0, BT848_INT_MASK);
4044 btwrite(~0x0, BT848_INT_STAT);
4045 btwrite(0x0, BT848_GPIO_OUT_EN);
4046 if (bttv_gpio)
4047 bttv_gpio_tracking(btv,"cleanup");
4048
4049 /* tell gpio modules we are leaving ... */
4050 btv->shutdown=1;
4051 wake_up(&btv->gpioq);
4052 bttv_sub_del_devices(&btv->c);
4053
4054 /* unregister i2c_bus + input */
4055 fini_bttv_i2c(btv);
4056
4057 /* unregister video4linux */
4058 bttv_unregister_video(btv);
4059
4060 /* free allocated memory */
4061 btcx_riscmem_free(btv->c.pci,&btv->main);
4062
4063 /* free ressources */
4064 free_irq(btv->c.pci->irq,btv);
4065 iounmap(btv->bt848_mmio);
4066 release_mem_region(pci_resource_start(btv->c.pci,0),
4067 pci_resource_len(btv->c.pci,0));
4068
4069 pci_set_drvdata(pci_dev, NULL);
4070 return;
4071}
4072
4073static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4074{
4075 struct bttv *btv = pci_get_drvdata(pci_dev);
4076 struct bttv_buffer_set idle;
4077 unsigned long flags;
4078
0f97a931 4079 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
1da177e4
LT		 4080
4081 /* stop dma + irqs */
4082 spin_lock_irqsave(&btv->s_lock,flags);
4083 memset(&idle, 0, sizeof(idle));
4084 btv->state.video = btv->curr;
4085 btv->state.vbi = btv->cvbi;
4086 btv->state.loop_irq = btv->loop_irq;
4087 btv->curr = idle;
4088 btv->loop_irq = 0;
4089 bttv_buffer_activate_video(btv, &idle);
4090 bttv_buffer_activate_vbi(btv, NULL);
4091 bttv_set_dma(btv, 0);
4092 btwrite(0, BT848_INT_MASK);
4093 spin_unlock_irqrestore(&btv->s_lock,flags);
4094
4095 /* save bt878 state */
4096 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4097 btv->state.gpio_data = gpio_read();
4098
4099 /* save pci state */
4100 pci_save_state(pci_dev);
4101 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4102 pci_disable_device(pci_dev);
4103 btv->state.disabled = 1;
4104 }
4105 return 0;
4106}
4107
4108static int bttv_resume(struct pci_dev *pci_dev)
4109{
4110 struct bttv *btv = pci_get_drvdata(pci_dev);
4111 unsigned long flags;
08adb9e2 4112 int err;
1da177e4
LT		 4113
4114 dprintk("bttv%d: resume\n", btv->c.nr);
4115
4116 /* restore pci state */
4117 if (btv->state.disabled) {
08adb9e2
MCC		 4118 err=pci_enable_device(pci_dev);
4119 if (err) {
4120 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4121 btv->c.nr);
4122 return err;
4123 }
1da177e4
LT		 4124 btv->state.disabled = 0;
4125 }
08adb9e2
MCC		 4126 err=pci_set_power_state(pci_dev, PCI_D0);
4127 if (err) {
4128 pci_disable_device(pci_dev);
4129 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4130 btv->c.nr);
4131 btv->state.disabled = 1;
4132 return err;
4133 }
4134
1da177e4
LT		 4135 pci_restore_state(pci_dev);
4136
4137 /* restore bt878 state */
4138 bttv_reinit_bt848(btv);
4139 gpio_inout(0xffffff, btv->state.gpio_enable);
4140 gpio_write(btv->state.gpio_data);
4141
4142 /* restart dma */
4143 spin_lock_irqsave(&btv->s_lock,flags);
4144 btv->curr = btv->state.video;
4145 btv->cvbi = btv->state.vbi;
4146 btv->loop_irq = btv->state.loop_irq;
4147 bttv_buffer_activate_video(btv, &btv->curr);
4148 bttv_buffer_activate_vbi(btv, btv->cvbi);
4149 bttv_set_dma(btv, 0);
4150 spin_unlock_irqrestore(&btv->s_lock,flags);
4151 return 0;
4152}
4153
4154static struct pci_device_id bttv_pci_tbl[] = {
4155 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4156 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4157 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4158 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4159 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4160 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4161 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4162 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4163 {0,}
4164};
4165
4166MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4167
4168static struct pci_driver bttv_pci_driver = {
4169 .name = "bttv",
4170 .id_table = bttv_pci_tbl,
4171 .probe = bttv_probe,
4172 .remove = __devexit_p(bttv_remove),
4173 .suspend = bttv_suspend,
4174 .resume = bttv_resume,
4175};
4176
4177static int bttv_init_module(void)
4178{
4179 bttv_num = 0;
4180
4181 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4182 (BTTV_VERSION_CODE >> 16) & 0xff,
4183 (BTTV_VERSION_CODE >> 8) & 0xff,
4184 BTTV_VERSION_CODE & 0xff);
4185#ifdef SNAPSHOT
4186 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4187 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4188#endif
4189 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4190 gbuffers = 2;
4191 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4192 gbufsize = BTTV_MAX_FBUF;
4193 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4194 if (bttv_verbose)
4195 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4196 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4197
4198 bttv_check_chipset();
4199
4200 bus_register(&bttv_sub_bus_type);
4201 return pci_module_init(&bttv_pci_driver);
4202}
4203
4204static void bttv_cleanup_module(void)
4205{
4206 pci_unregister_driver(&bttv_pci_driver);
4207 bus_unregister(&bttv_sub_bus_type);
4208 return;
4209}
4210
4211module_init(bttv_init_module);
4212module_exit(bttv_cleanup_module);
4213
4214/*
4215 * Local variables:
4216 * c-basic-offset: 8
4217 * End:
4218 */
Ubuntu Hirsute Linux kernel mirror