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