]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/video/bt8xx/bttv-driver.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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