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