]> 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 error-inject 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 route.input = MSP_INPUT_DEFAULT;
1222 break;
1223 }
1224 route.output = MSP_OUTPUT_DEFAULT;
1225 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1226 }
1227 c = btv->i2c_tvaudio_client;
1228 if (c) {
1229 struct v4l2_routing route;
1230
1231 route.input = input;
1232 route.output = 0;
1233 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1234 }
1235 return 0;
1236 }
1237
1238 static inline int
1239 audio_mute(struct bttv *btv, int mute)
1240 {
1241 return audio_mux(btv, btv->audio, mute);
1242 }
1243
1244 static inline int
1245 audio_input(struct bttv *btv, int input)
1246 {
1247 return audio_mux(btv, input, btv->mute);
1248 }
1249
1250 static void
1251 i2c_vidiocschan(struct bttv *btv)
1252 {
1253 v4l2_std_id std = bttv_tvnorms[btv->tvnorm].v4l2_id;
1254
1255 bttv_call_i2c_clients(btv, VIDIOC_S_STD, &std);
1256 if (btv->c.type == BTTV_BOARD_VOODOOTV_FM)
1257 bttv_tda9880_setnorm(btv,btv->tvnorm);
1258 }
1259
1260 static void
1261 bttv_crop_calc_limits(struct bttv_crop *c)
1262 {
1263 /* Scale factor min. 1:1, max. 16:1. Min. image size
1264 48 x 32. Scaled width must be a multiple of 4. */
1265
1266 if (1) {
1267 /* For bug compatibility with VIDIOCGCAP and image
1268 size checks in earlier driver versions. */
1269 c->min_scaled_width = 48;
1270 c->min_scaled_height = 32;
1271 } else {
1272 c->min_scaled_width =
1273 (max(48, c->rect.width >> 4) + 3) & ~3;
1274 c->min_scaled_height =
1275 max(32, c->rect.height >> 4);
1276 }
1277
1278 c->max_scaled_width = c->rect.width & ~3;
1279 c->max_scaled_height = c->rect.height;
1280 }
1281
1282 static void
1283 bttv_crop_reset(struct bttv_crop *c, int norm)
1284 {
1285 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1286 bttv_crop_calc_limits(c);
1287 }
1288
1289 /* Call with btv->lock down. */
1290 static int
1291 set_tvnorm(struct bttv *btv, unsigned int norm)
1292 {
1293 const struct bttv_tvnorm *tvnorm;
1294
1295 if (norm < 0 || norm >= BTTV_TVNORMS)
1296 return -EINVAL;
1297
1298 tvnorm = &bttv_tvnorms[norm];
1299
1300 if (btv->tvnorm < 0 ||
1301 btv->tvnorm >= BTTV_TVNORMS ||
1302 0 != memcmp(&bttv_tvnorms[btv->tvnorm].cropcap,
1303 &tvnorm->cropcap,
1304 sizeof (tvnorm->cropcap))) {
1305 bttv_crop_reset(&btv->crop[0], norm);
1306 btv->crop[1] = btv->crop[0]; /* current = default */
1307
1308 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1309 btv->crop_start = tvnorm->cropcap.bounds.top
1310 + tvnorm->cropcap.bounds.height;
1311 }
1312 }
1313
1314 btv->tvnorm = norm;
1315
1316 btwrite(tvnorm->adelay, BT848_ADELAY);
1317 btwrite(tvnorm->bdelay, BT848_BDELAY);
1318 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1319 BT848_IFORM);
1320 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1321 btwrite(1, BT848_VBI_PACK_DEL);
1322 bt848A_set_timing(btv);
1323
1324 switch (btv->c.type) {
1325 case BTTV_BOARD_VOODOOTV_FM:
1326 bttv_tda9880_setnorm(btv,norm);
1327 break;
1328 }
1329 return 0;
1330 }
1331
1332 /* Call with btv->lock down. */
1333 static void
1334 set_input(struct bttv *btv, unsigned int input)
1335 {
1336 unsigned long flags;
1337
1338 btv->input = input;
1339 if (irq_iswitch) {
1340 spin_lock_irqsave(&btv->s_lock,flags);
1341 if (btv->curr.frame_irq) {
1342 /* active capture -> delayed input switch */
1343 btv->new_input = input;
1344 } else {
1345 video_mux(btv,input);
1346 }
1347 spin_unlock_irqrestore(&btv->s_lock,flags);
1348 } else {
1349 video_mux(btv,input);
1350 }
1351 audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1352 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1353 set_tvnorm(btv,btv->tvnorm);
1354 i2c_vidiocschan(btv);
1355 }
1356
1357 static void init_irqreg(struct bttv *btv)
1358 {
1359 /* clear status */
1360 btwrite(0xfffffUL, BT848_INT_STAT);
1361
1362 if (bttv_tvcards[btv->c.type].no_video) {
1363 /* i2c only */
1364 btwrite(BT848_INT_I2CDONE,
1365 BT848_INT_MASK);
1366 } else {
1367 /* full video */
1368 btwrite((btv->triton1) |
1369 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1370 BT848_INT_SCERR |
1371 (fdsr ? BT848_INT_FDSR : 0) |
1372 BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1373 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1374 BT848_INT_I2CDONE,
1375 BT848_INT_MASK);
1376 }
1377 }
1378
1379 static void init_bt848(struct bttv *btv)
1380 {
1381 int val;
1382
1383 if (bttv_tvcards[btv->c.type].no_video) {
1384 /* very basic init only */
1385 init_irqreg(btv);
1386 return;
1387 }
1388
1389 btwrite(0x00, BT848_CAP_CTL);
1390 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1391 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1392
1393 /* set planar and packed mode trigger points and */
1394 /* set rising edge of inverted GPINTR pin as irq trigger */
1395 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1396 BT848_GPIO_DMA_CTL_PLTP1_16|
1397 BT848_GPIO_DMA_CTL_PLTP23_16|
1398 BT848_GPIO_DMA_CTL_GPINTC|
1399 BT848_GPIO_DMA_CTL_GPINTI,
1400 BT848_GPIO_DMA_CTL);
1401
1402 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1403 btwrite(val, BT848_E_SCLOOP);
1404 btwrite(val, BT848_O_SCLOOP);
1405
1406 btwrite(0x20, BT848_E_VSCALE_HI);
1407 btwrite(0x20, BT848_O_VSCALE_HI);
1408 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1409 BT848_ADC);
1410
1411 btwrite(whitecrush_upper, BT848_WC_UP);
1412 btwrite(whitecrush_lower, BT848_WC_DOWN);
1413
1414 if (btv->opt_lumafilter) {
1415 btwrite(0, BT848_E_CONTROL);
1416 btwrite(0, BT848_O_CONTROL);
1417 } else {
1418 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1419 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1420 }
1421
1422 bt848_bright(btv, btv->bright);
1423 bt848_hue(btv, btv->hue);
1424 bt848_contrast(btv, btv->contrast);
1425 bt848_sat(btv, btv->saturation);
1426
1427 /* interrupt */
1428 init_irqreg(btv);
1429 }
1430
1431 static void bttv_reinit_bt848(struct bttv *btv)
1432 {
1433 unsigned long flags;
1434
1435 if (bttv_verbose)
1436 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1437 spin_lock_irqsave(&btv->s_lock,flags);
1438 btv->errors=0;
1439 bttv_set_dma(btv,0);
1440 spin_unlock_irqrestore(&btv->s_lock,flags);
1441
1442 init_bt848(btv);
1443 btv->pll.pll_current = -1;
1444 set_input(btv,btv->input);
1445 }
1446
1447 static int get_control(struct bttv *btv, struct v4l2_control *c)
1448 {
1449 struct video_audio va;
1450 int i;
1451
1452 for (i = 0; i < BTTV_CTLS; i++)
1453 if (bttv_ctls[i].id == c->id)
1454 break;
1455 if (i == BTTV_CTLS)
1456 return -EINVAL;
1457 if (btv->audio_hook && i >= 4 && i <= 8) {
1458 memset(&va,0,sizeof(va));
1459 btv->audio_hook(btv,&va,0);
1460 switch (c->id) {
1461 case V4L2_CID_AUDIO_MUTE:
1462 c->value = (VIDEO_AUDIO_MUTE & va.flags) ? 1 : 0;
1463 break;
1464 case V4L2_CID_AUDIO_VOLUME:
1465 c->value = va.volume;
1466 break;
1467 case V4L2_CID_AUDIO_BALANCE:
1468 c->value = va.balance;
1469 break;
1470 case V4L2_CID_AUDIO_BASS:
1471 c->value = va.bass;
1472 break;
1473 case V4L2_CID_AUDIO_TREBLE:
1474 c->value = va.treble;
1475 break;
1476 }
1477 return 0;
1478 }
1479 switch (c->id) {
1480 case V4L2_CID_BRIGHTNESS:
1481 c->value = btv->bright;
1482 break;
1483 case V4L2_CID_HUE:
1484 c->value = btv->hue;
1485 break;
1486 case V4L2_CID_CONTRAST:
1487 c->value = btv->contrast;
1488 break;
1489 case V4L2_CID_SATURATION:
1490 c->value = btv->saturation;
1491 break;
1492
1493 case V4L2_CID_AUDIO_MUTE:
1494 case V4L2_CID_AUDIO_VOLUME:
1495 case V4L2_CID_AUDIO_BALANCE:
1496 case V4L2_CID_AUDIO_BASS:
1497 case V4L2_CID_AUDIO_TREBLE:
1498 bttv_call_i2c_clients(btv,VIDIOC_G_CTRL,c);
1499 break;
1500
1501 case V4L2_CID_PRIVATE_CHROMA_AGC:
1502 c->value = btv->opt_chroma_agc;
1503 break;
1504 case V4L2_CID_PRIVATE_COMBFILTER:
1505 c->value = btv->opt_combfilter;
1506 break;
1507 case V4L2_CID_PRIVATE_LUMAFILTER:
1508 c->value = btv->opt_lumafilter;
1509 break;
1510 case V4L2_CID_PRIVATE_AUTOMUTE:
1511 c->value = btv->opt_automute;
1512 break;
1513 case V4L2_CID_PRIVATE_AGC_CRUSH:
1514 c->value = btv->opt_adc_crush;
1515 break;
1516 case V4L2_CID_PRIVATE_VCR_HACK:
1517 c->value = btv->opt_vcr_hack;
1518 break;
1519 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1520 c->value = btv->opt_whitecrush_upper;
1521 break;
1522 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1523 c->value = btv->opt_whitecrush_lower;
1524 break;
1525 case V4L2_CID_PRIVATE_UV_RATIO:
1526 c->value = btv->opt_uv_ratio;
1527 break;
1528 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1529 c->value = btv->opt_full_luma_range;
1530 break;
1531 case V4L2_CID_PRIVATE_CORING:
1532 c->value = btv->opt_coring;
1533 break;
1534 default:
1535 return -EINVAL;
1536 }
1537 return 0;
1538 }
1539
1540 static int set_control(struct bttv *btv, struct v4l2_control *c)
1541 {
1542 struct video_audio va;
1543 int i,val;
1544
1545 for (i = 0; i < BTTV_CTLS; i++)
1546 if (bttv_ctls[i].id == c->id)
1547 break;
1548 if (i == BTTV_CTLS)
1549 return -EINVAL;
1550 if (btv->audio_hook && i >= 4 && i <= 8) {
1551 memset(&va,0,sizeof(va));
1552 btv->audio_hook(btv,&va,0);
1553 switch (c->id) {
1554 case V4L2_CID_AUDIO_MUTE:
1555 if (c->value) {
1556 va.flags |= VIDEO_AUDIO_MUTE;
1557 audio_mute(btv, 1);
1558 } else {
1559 va.flags &= ~VIDEO_AUDIO_MUTE;
1560 audio_mute(btv, 0);
1561 }
1562 break;
1563
1564 case V4L2_CID_AUDIO_VOLUME:
1565 va.volume = c->value;
1566 break;
1567 case V4L2_CID_AUDIO_BALANCE:
1568 va.balance = c->value;
1569 break;
1570 case V4L2_CID_AUDIO_BASS:
1571 va.bass = c->value;
1572 break;
1573 case V4L2_CID_AUDIO_TREBLE:
1574 va.treble = c->value;
1575 break;
1576 }
1577 btv->audio_hook(btv,&va,1);
1578 return 0;
1579 }
1580 switch (c->id) {
1581 case V4L2_CID_BRIGHTNESS:
1582 bt848_bright(btv,c->value);
1583 break;
1584 case V4L2_CID_HUE:
1585 bt848_hue(btv,c->value);
1586 break;
1587 case V4L2_CID_CONTRAST:
1588 bt848_contrast(btv,c->value);
1589 break;
1590 case V4L2_CID_SATURATION:
1591 bt848_sat(btv,c->value);
1592 break;
1593 case V4L2_CID_AUDIO_MUTE:
1594 audio_mute(btv, c->value);
1595 /* fall through */
1596 case V4L2_CID_AUDIO_VOLUME:
1597 case V4L2_CID_AUDIO_BALANCE:
1598 case V4L2_CID_AUDIO_BASS:
1599 case V4L2_CID_AUDIO_TREBLE:
1600 bttv_call_i2c_clients(btv,VIDIOC_S_CTRL,c);
1601 break;
1602
1603 case V4L2_CID_PRIVATE_CHROMA_AGC:
1604 btv->opt_chroma_agc = c->value;
1605 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1606 btwrite(val, BT848_E_SCLOOP);
1607 btwrite(val, BT848_O_SCLOOP);
1608 break;
1609 case V4L2_CID_PRIVATE_COMBFILTER:
1610 btv->opt_combfilter = c->value;
1611 break;
1612 case V4L2_CID_PRIVATE_LUMAFILTER:
1613 btv->opt_lumafilter = c->value;
1614 if (btv->opt_lumafilter) {
1615 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1616 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1617 } else {
1618 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1619 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1620 }
1621 break;
1622 case V4L2_CID_PRIVATE_AUTOMUTE:
1623 btv->opt_automute = c->value;
1624 break;
1625 case V4L2_CID_PRIVATE_AGC_CRUSH:
1626 btv->opt_adc_crush = c->value;
1627 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1628 BT848_ADC);
1629 break;
1630 case V4L2_CID_PRIVATE_VCR_HACK:
1631 btv->opt_vcr_hack = c->value;
1632 break;
1633 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1634 btv->opt_whitecrush_upper = c->value;
1635 btwrite(c->value, BT848_WC_UP);
1636 break;
1637 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1638 btv->opt_whitecrush_lower = c->value;
1639 btwrite(c->value, BT848_WC_DOWN);
1640 break;
1641 case V4L2_CID_PRIVATE_UV_RATIO:
1642 btv->opt_uv_ratio = c->value;
1643 bt848_sat(btv, btv->saturation);
1644 break;
1645 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1646 btv->opt_full_luma_range = c->value;
1647 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1648 break;
1649 case V4L2_CID_PRIVATE_CORING:
1650 btv->opt_coring = c->value;
1651 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1652 break;
1653 default:
1654 return -EINVAL;
1655 }
1656 return 0;
1657 }
1658
1659 /* ----------------------------------------------------------------------- */
1660
1661 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1662 {
1663 unsigned int outbits, data;
1664 outbits = btread(BT848_GPIO_OUT_EN);
1665 data = btread(BT848_GPIO_DATA);
1666 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1667 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1668 }
1669
1670 static void bttv_field_count(struct bttv *btv)
1671 {
1672 int need_count = 0;
1673
1674 if (btv->users)
1675 need_count++;
1676
1677 if (need_count) {
1678 /* start field counter */
1679 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1680 } else {
1681 /* stop field counter */
1682 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1683 btv->field_count = 0;
1684 }
1685 }
1686
1687 static const struct bttv_format*
1688 format_by_palette(int palette)
1689 {
1690 unsigned int i;
1691
1692 for (i = 0; i < BTTV_FORMATS; i++) {
1693 if (-1 == bttv_formats[i].palette)
1694 continue;
1695 if (bttv_formats[i].palette == palette)
1696 return bttv_formats+i;
1697 }
1698 return NULL;
1699 }
1700
1701 static const struct bttv_format*
1702 format_by_fourcc(int fourcc)
1703 {
1704 unsigned int i;
1705
1706 for (i = 0; i < BTTV_FORMATS; i++) {
1707 if (-1 == bttv_formats[i].fourcc)
1708 continue;
1709 if (bttv_formats[i].fourcc == fourcc)
1710 return bttv_formats+i;
1711 }
1712 return NULL;
1713 }
1714
1715 /* ----------------------------------------------------------------------- */
1716 /* misc helpers */
1717
1718 static int
1719 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1720 struct bttv_buffer *new)
1721 {
1722 struct bttv_buffer *old;
1723 unsigned long flags;
1724 int retval = 0;
1725
1726 dprintk("switch_overlay: enter [new=%p]\n",new);
1727 if (new)
1728 new->vb.state = STATE_DONE;
1729 spin_lock_irqsave(&btv->s_lock,flags);
1730 old = btv->screen;
1731 btv->screen = new;
1732 btv->loop_irq |= 1;
1733 bttv_set_dma(btv, 0x03);
1734 spin_unlock_irqrestore(&btv->s_lock,flags);
1735 if (NULL != old) {
1736 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1737 bttv_dma_free(&fh->cap,btv, old);
1738 kfree(old);
1739 }
1740 if (NULL == new)
1741 free_btres(btv,fh,RESOURCE_OVERLAY);
1742 dprintk("switch_overlay: done\n");
1743 return retval;
1744 }
1745
1746 /* ----------------------------------------------------------------------- */
1747 /* video4linux (1) interface */
1748
1749 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1750 struct bttv_buffer *buf,
1751 const struct bttv_format *fmt,
1752 unsigned int width, unsigned int height,
1753 enum v4l2_field field)
1754 {
1755 struct bttv_fh *fh = q->priv_data;
1756 int redo_dma_risc = 0;
1757 struct bttv_crop c;
1758 int norm;
1759 int rc;
1760
1761 /* check settings */
1762 if (NULL == fmt)
1763 return -EINVAL;
1764 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1765 width = RAW_BPL;
1766 height = RAW_LINES*2;
1767 if (width*height > buf->vb.bsize)
1768 return -EINVAL;
1769 buf->vb.size = buf->vb.bsize;
1770
1771 /* Make sure tvnorm and vbi_end remain consistent
1772 until we're done. */
1773 mutex_lock(&btv->lock);
1774
1775 norm = btv->tvnorm;
1776
1777 /* In this mode capturing always starts at defrect.top
1778 (default VDELAY), ignoring cropping parameters. */
1779 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1780 mutex_unlock(&btv->lock);
1781 return -EINVAL;
1782 }
1783
1784 mutex_unlock(&btv->lock);
1785
1786 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1787 } else {
1788 mutex_lock(&btv->lock);
1789
1790 norm = btv->tvnorm;
1791 c = btv->crop[!!fh->do_crop];
1792
1793 mutex_unlock(&btv->lock);
1794
1795 if (width < c.min_scaled_width ||
1796 width > c.max_scaled_width ||
1797 height < c.min_scaled_height)
1798 return -EINVAL;
1799
1800 switch (field) {
1801 case V4L2_FIELD_TOP:
1802 case V4L2_FIELD_BOTTOM:
1803 case V4L2_FIELD_ALTERNATE:
1804 /* btv->crop counts frame lines. Max. scale
1805 factor is 16:1 for frames, 8:1 for fields. */
1806 if (height * 2 > c.max_scaled_height)
1807 return -EINVAL;
1808 break;
1809
1810 default:
1811 if (height > c.max_scaled_height)
1812 return -EINVAL;
1813 break;
1814 }
1815
1816 buf->vb.size = (width * height * fmt->depth) >> 3;
1817 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1818 return -EINVAL;
1819 }
1820
1821 /* alloc + fill struct bttv_buffer (if changed) */
1822 if (buf->vb.width != width || buf->vb.height != height ||
1823 buf->vb.field != field ||
1824 buf->tvnorm != norm || buf->fmt != fmt ||
1825 buf->crop.top != c.rect.top ||
1826 buf->crop.left != c.rect.left ||
1827 buf->crop.width != c.rect.width ||
1828 buf->crop.height != c.rect.height) {
1829 buf->vb.width = width;
1830 buf->vb.height = height;
1831 buf->vb.field = field;
1832 buf->tvnorm = norm;
1833 buf->fmt = fmt;
1834 buf->crop = c.rect;
1835 redo_dma_risc = 1;
1836 }
1837
1838 /* alloc risc memory */
1839 if (STATE_NEEDS_INIT == buf->vb.state) {
1840 redo_dma_risc = 1;
1841 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1842 goto fail;
1843 }
1844
1845 if (redo_dma_risc)
1846 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1847 goto fail;
1848
1849 buf->vb.state = STATE_PREPARED;
1850 return 0;
1851
1852 fail:
1853 bttv_dma_free(q,btv,buf);
1854 return rc;
1855 }
1856
1857 static int
1858 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1859 {
1860 struct bttv_fh *fh = q->priv_data;
1861
1862 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1863 if (0 == *count)
1864 *count = gbuffers;
1865 while (*size * *count > gbuffers * gbufsize)
1866 (*count)--;
1867 return 0;
1868 }
1869
1870 static int
1871 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1872 enum v4l2_field field)
1873 {
1874 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1875 struct bttv_fh *fh = q->priv_data;
1876
1877 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1878 fh->width, fh->height, field);
1879 }
1880
1881 static void
1882 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1883 {
1884 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1885 struct bttv_fh *fh = q->priv_data;
1886 struct bttv *btv = fh->btv;
1887
1888 buf->vb.state = STATE_QUEUED;
1889 list_add_tail(&buf->vb.queue,&btv->capture);
1890 if (!btv->curr.frame_irq) {
1891 btv->loop_irq |= 1;
1892 bttv_set_dma(btv, 0x03);
1893 }
1894 }
1895
1896 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1897 {
1898 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1899 struct bttv_fh *fh = q->priv_data;
1900
1901 bttv_dma_free(q,fh->btv,buf);
1902 }
1903
1904 static struct videobuf_queue_ops bttv_video_qops = {
1905 .buf_setup = buffer_setup,
1906 .buf_prepare = buffer_prepare,
1907 .buf_queue = buffer_queue,
1908 .buf_release = buffer_release,
1909 };
1910
1911 static int bttv_common_ioctls(struct bttv *btv, unsigned int cmd, void *arg)
1912 {
1913 switch (cmd) {
1914 case BTTV_VERSION:
1915 return BTTV_VERSION_CODE;
1916
1917 /* *** v4l1 *** ************************************************ */
1918 case VIDIOCGFREQ:
1919 {
1920 unsigned long *freq = arg;
1921 *freq = btv->freq;
1922 return 0;
1923 }
1924 case VIDIOCSFREQ:
1925 {
1926 struct v4l2_frequency freq;
1927
1928 memset(&freq, 0, sizeof(freq));
1929 freq.frequency = *(unsigned long *)arg;
1930 mutex_lock(&btv->lock);
1931 freq.type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1932 btv->freq = *(unsigned long *)arg;
1933 bttv_call_i2c_clients(btv,VIDIOC_S_FREQUENCY,&freq);
1934 if (btv->has_matchbox && btv->radio_user)
1935 tea5757_set_freq(btv,*(unsigned long *)arg);
1936 mutex_unlock(&btv->lock);
1937 return 0;
1938 }
1939
1940 case VIDIOCGTUNER:
1941 {
1942 struct video_tuner *v = arg;
1943
1944 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1945 return -EINVAL;
1946 if (v->tuner) /* Only tuner 0 */
1947 return -EINVAL;
1948 strcpy(v->name, "Television");
1949 v->rangelow = 0;
1950 v->rangehigh = 0x7FFFFFFF;
1951 v->flags = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1952 v->mode = btv->tvnorm;
1953 v->signal = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
1954 bttv_call_i2c_clients(btv,cmd,v);
1955 return 0;
1956 }
1957 case VIDIOCSTUNER:
1958 {
1959 struct video_tuner *v = arg;
1960
1961 if (v->tuner) /* Only tuner 0 */
1962 return -EINVAL;
1963 if (v->mode >= BTTV_TVNORMS)
1964 return -EINVAL;
1965
1966 mutex_lock(&btv->lock);
1967 set_tvnorm(btv,v->mode);
1968 bttv_call_i2c_clients(btv,cmd,v);
1969 mutex_unlock(&btv->lock);
1970 return 0;
1971 }
1972
1973 case VIDIOCGCHAN:
1974 {
1975 struct video_channel *v = arg;
1976 unsigned int channel = v->channel;
1977
1978 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
1979 return -EINVAL;
1980 v->tuners=0;
1981 v->flags = VIDEO_VC_AUDIO;
1982 v->type = VIDEO_TYPE_CAMERA;
1983 v->norm = btv->tvnorm;
1984 if (channel == bttv_tvcards[btv->c.type].tuner) {
1985 strcpy(v->name,"Television");
1986 v->flags|=VIDEO_VC_TUNER;
1987 v->type=VIDEO_TYPE_TV;
1988 v->tuners=1;
1989 } else if (channel == btv->svhs) {
1990 strcpy(v->name,"S-Video");
1991 } else {
1992 sprintf(v->name,"Composite%d",channel);
1993 }
1994 return 0;
1995 }
1996 case VIDIOCSCHAN:
1997 {
1998 struct video_channel *v = arg;
1999 unsigned int channel = v->channel;
2000
2001 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
2002 return -EINVAL;
2003 if (v->norm >= BTTV_TVNORMS)
2004 return -EINVAL;
2005
2006 mutex_lock(&btv->lock);
2007 if (channel == btv->input &&
2008 v->norm == btv->tvnorm) {
2009 /* nothing to do */
2010 mutex_unlock(&btv->lock);
2011 return 0;
2012 }
2013
2014 btv->tvnorm = v->norm;
2015 set_input(btv,v->channel);
2016 mutex_unlock(&btv->lock);
2017 return 0;
2018 }
2019
2020 case VIDIOCGAUDIO:
2021 {
2022 struct video_audio *v = arg;
2023
2024 memset(v,0,sizeof(*v));
2025 strcpy(v->name,"Television");
2026 v->flags |= VIDEO_AUDIO_MUTABLE;
2027 v->mode = VIDEO_SOUND_MONO;
2028
2029 mutex_lock(&btv->lock);
2030 bttv_call_i2c_clients(btv,cmd,v);
2031
2032 /* card specific hooks */
2033 if (btv->audio_hook)
2034 btv->audio_hook(btv,v,0);
2035
2036 mutex_unlock(&btv->lock);
2037 return 0;
2038 }
2039 case VIDIOCSAUDIO:
2040 {
2041 struct video_audio *v = arg;
2042 unsigned int audio = v->audio;
2043
2044 if (audio >= bttv_tvcards[btv->c.type].audio_inputs)
2045 return -EINVAL;
2046
2047 mutex_lock(&btv->lock);
2048 audio_mute(btv, (v->flags&VIDEO_AUDIO_MUTE) ? 1 : 0);
2049 bttv_call_i2c_clients(btv,cmd,v);
2050
2051 /* card specific hooks */
2052 if (btv->audio_hook)
2053 btv->audio_hook(btv,v,1);
2054
2055 mutex_unlock(&btv->lock);
2056 return 0;
2057 }
2058
2059 /* *** v4l2 *** ************************************************ */
2060 case VIDIOC_ENUMSTD:
2061 {
2062 struct v4l2_standard *e = arg;
2063 unsigned int index = e->index;
2064
2065 if (index >= BTTV_TVNORMS)
2066 return -EINVAL;
2067 v4l2_video_std_construct(e, bttv_tvnorms[e->index].v4l2_id,
2068 bttv_tvnorms[e->index].name);
2069 e->index = index;
2070 return 0;
2071 }
2072 case VIDIOC_G_STD:
2073 {
2074 v4l2_std_id *id = arg;
2075 *id = bttv_tvnorms[btv->tvnorm].v4l2_id;
2076 return 0;
2077 }
2078 case VIDIOC_S_STD:
2079 {
2080 v4l2_std_id *id = arg;
2081 unsigned int i;
2082
2083 for (i = 0; i < BTTV_TVNORMS; i++)
2084 if (*id & bttv_tvnorms[i].v4l2_id)
2085 break;
2086 if (i == BTTV_TVNORMS)
2087 return -EINVAL;
2088
2089 mutex_lock(&btv->lock);
2090 set_tvnorm(btv,i);
2091 i2c_vidiocschan(btv);
2092 mutex_unlock(&btv->lock);
2093 return 0;
2094 }
2095 case VIDIOC_QUERYSTD:
2096 {
2097 v4l2_std_id *id = arg;
2098
2099 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
2100 *id = V4L2_STD_625_50;
2101 else
2102 *id = V4L2_STD_525_60;
2103 return 0;
2104 }
2105
2106 case VIDIOC_ENUMINPUT:
2107 {
2108 struct v4l2_input *i = arg;
2109 unsigned int n;
2110
2111 n = i->index;
2112 if (n >= bttv_tvcards[btv->c.type].video_inputs)
2113 return -EINVAL;
2114 memset(i,0,sizeof(*i));
2115 i->index = n;
2116 i->type = V4L2_INPUT_TYPE_CAMERA;
2117 i->audioset = 1;
2118 if (i->index == bttv_tvcards[btv->c.type].tuner) {
2119 sprintf(i->name, "Television");
2120 i->type = V4L2_INPUT_TYPE_TUNER;
2121 i->tuner = 0;
2122 } else if (i->index == btv->svhs) {
2123 sprintf(i->name, "S-Video");
2124 } else {
2125 sprintf(i->name,"Composite%d",i->index);
2126 }
2127 if (i->index == btv->input) {
2128 __u32 dstatus = btread(BT848_DSTATUS);
2129 if (0 == (dstatus & BT848_DSTATUS_PRES))
2130 i->status |= V4L2_IN_ST_NO_SIGNAL;
2131 if (0 == (dstatus & BT848_DSTATUS_HLOC))
2132 i->status |= V4L2_IN_ST_NO_H_LOCK;
2133 }
2134 for (n = 0; n < BTTV_TVNORMS; n++)
2135 i->std |= bttv_tvnorms[n].v4l2_id;
2136 return 0;
2137 }
2138 case VIDIOC_G_INPUT:
2139 {
2140 int *i = arg;
2141 *i = btv->input;
2142 return 0;
2143 }
2144 case VIDIOC_S_INPUT:
2145 {
2146 unsigned int *i = arg;
2147
2148 if (*i > bttv_tvcards[btv->c.type].video_inputs)
2149 return -EINVAL;
2150 mutex_lock(&btv->lock);
2151 set_input(btv,*i);
2152 mutex_unlock(&btv->lock);
2153 return 0;
2154 }
2155
2156 case VIDIOC_G_TUNER:
2157 {
2158 struct v4l2_tuner *t = arg;
2159
2160 if (UNSET == bttv_tvcards[btv->c.type].tuner)
2161 return -EINVAL;
2162 if (0 != t->index)
2163 return -EINVAL;
2164 mutex_lock(&btv->lock);
2165 memset(t,0,sizeof(*t));
2166 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2167 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
2168 strcpy(t->name, "Television");
2169 t->capability = V4L2_TUNER_CAP_NORM;
2170 t->type = V4L2_TUNER_ANALOG_TV;
2171 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2172 t->signal = 0xffff;
2173
2174 if (btv->audio_hook) {
2175 /* Hmmm ... */
2176 struct video_audio va;
2177 memset(&va, 0, sizeof(struct video_audio));
2178 btv->audio_hook(btv,&va,0);
2179 t->audmode = V4L2_TUNER_MODE_MONO;
2180 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2181 if(va.mode & VIDEO_SOUND_STEREO) {
2182 t->audmode = V4L2_TUNER_MODE_STEREO;
2183 t->rxsubchans = V4L2_TUNER_SUB_STEREO;
2184 }
2185 if(va.mode & VIDEO_SOUND_LANG2) {
2186 t->audmode = V4L2_TUNER_MODE_LANG1;
2187 t->rxsubchans = V4L2_TUNER_SUB_LANG1
2188 | V4L2_TUNER_SUB_LANG2;
2189 }
2190 }
2191 /* FIXME: fill capability+audmode */
2192 mutex_unlock(&btv->lock);
2193 return 0;
2194 }
2195 case VIDIOC_S_TUNER:
2196 {
2197 struct v4l2_tuner *t = arg;
2198
2199 if (UNSET == bttv_tvcards[btv->c.type].tuner)
2200 return -EINVAL;
2201 if (0 != t->index)
2202 return -EINVAL;
2203 mutex_lock(&btv->lock);
2204 bttv_call_i2c_clients(btv, VIDIOC_S_TUNER, t);
2205 if (btv->audio_hook) {
2206 struct video_audio va;
2207 memset(&va, 0, sizeof(struct video_audio));
2208 if (t->audmode == V4L2_TUNER_MODE_MONO)
2209 va.mode = VIDEO_SOUND_MONO;
2210 else if (t->audmode == V4L2_TUNER_MODE_STEREO ||
2211 t->audmode == V4L2_TUNER_MODE_LANG1_LANG2)
2212 va.mode = VIDEO_SOUND_STEREO;
2213 else if (t->audmode == V4L2_TUNER_MODE_LANG1)
2214 va.mode = VIDEO_SOUND_LANG1;
2215 else if (t->audmode == V4L2_TUNER_MODE_LANG2)
2216 va.mode = VIDEO_SOUND_LANG2;
2217 btv->audio_hook(btv,&va,1);
2218 }
2219 mutex_unlock(&btv->lock);
2220 return 0;
2221 }
2222
2223 case VIDIOC_G_FREQUENCY:
2224 {
2225 struct v4l2_frequency *f = arg;
2226
2227 memset(f,0,sizeof(*f));
2228 f->type = V4L2_TUNER_ANALOG_TV;
2229 f->frequency = btv->freq;
2230 return 0;
2231 }
2232 case VIDIOC_S_FREQUENCY:
2233 {
2234 struct v4l2_frequency *f = arg;
2235
2236 if (unlikely(f->tuner != 0))
2237 return -EINVAL;
2238 if (unlikely (f->type != V4L2_TUNER_ANALOG_TV))
2239 return -EINVAL;
2240 mutex_lock(&btv->lock);
2241 btv->freq = f->frequency;
2242 bttv_call_i2c_clients(btv,VIDIOC_S_FREQUENCY,f);
2243 if (btv->has_matchbox && btv->radio_user)
2244 tea5757_set_freq(btv,btv->freq);
2245 mutex_unlock(&btv->lock);
2246 return 0;
2247 }
2248 case VIDIOC_LOG_STATUS:
2249 {
2250 printk(KERN_INFO "bttv%d: ================= START STATUS CARD #%d =================\n", btv->c.nr, btv->c.nr);
2251 bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
2252 printk(KERN_INFO "bttv%d: ================== END STATUS CARD #%d ==================\n", btv->c.nr, btv->c.nr);
2253 return 0;
2254 }
2255
2256 default:
2257 return -ENOIOCTLCMD;
2258
2259 }
2260 return 0;
2261 }
2262
2263 /* Given cropping boundaries b and the scaled width and height of a
2264 single field or frame, which must not exceed hardware limits, this
2265 function adjusts the cropping parameters c. */
2266 static void
2267 bttv_crop_adjust (struct bttv_crop * c,
2268 const struct v4l2_rect * b,
2269 __s32 width,
2270 __s32 height,
2271 enum v4l2_field field)
2272 {
2273 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2274 __s32 max_left;
2275 __s32 max_top;
2276
2277 if (width < c->min_scaled_width) {
2278 /* Max. hor. scale factor 16:1. */
2279 c->rect.width = width * 16;
2280 } else if (width > c->max_scaled_width) {
2281 /* Min. hor. scale factor 1:1. */
2282 c->rect.width = width;
2283
2284 max_left = b->left + b->width - width;
2285 max_left = min(max_left, (__s32) MAX_HDELAY);
2286 if (c->rect.left > max_left)
2287 c->rect.left = max_left;
2288 }
2289
2290 if (height < c->min_scaled_height) {
2291 /* Max. vert. scale factor 16:1, single fields 8:1. */
2292 c->rect.height = height * 16;
2293 } else if (frame_height > c->max_scaled_height) {
2294 /* Min. vert. scale factor 1:1.
2295 Top and height count field lines times two. */
2296 c->rect.height = (frame_height + 1) & ~1;
2297
2298 max_top = b->top + b->height - c->rect.height;
2299 if (c->rect.top > max_top)
2300 c->rect.top = max_top;
2301 }
2302
2303 bttv_crop_calc_limits(c);
2304 }
2305
2306 /* Returns an error if scaling to a frame or single field with the given
2307 width and height is not possible with the current cropping parameters
2308 and width aligned according to width_mask. If adjust_size is TRUE the
2309 function may adjust the width and/or height instead, rounding width
2310 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2311 also adjust the current cropping parameters to get closer to the
2312 desired image size. */
2313 static int
2314 limit_scaled_size (struct bttv_fh * fh,
2315 __s32 * width,
2316 __s32 * height,
2317 enum v4l2_field field,
2318 unsigned int width_mask,
2319 unsigned int width_bias,
2320 int adjust_size,
2321 int adjust_crop)
2322 {
2323 struct bttv *btv = fh->btv;
2324 const struct v4l2_rect *b;
2325 struct bttv_crop *c;
2326 __s32 min_width;
2327 __s32 min_height;
2328 __s32 max_width;
2329 __s32 max_height;
2330 int rc;
2331
2332 BUG_ON((int) width_mask >= 0 ||
2333 width_bias >= (unsigned int) -width_mask);
2334
2335 /* Make sure tvnorm, vbi_end and the current cropping parameters
2336 remain consistent until we're done. */
2337 mutex_lock(&btv->lock);
2338
2339 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2340
2341 /* Do crop - use current, don't - use default parameters. */
2342 c = &btv->crop[!!fh->do_crop];
2343
2344 if (fh->do_crop
2345 && adjust_size
2346 && adjust_crop
2347 && !locked_btres(btv, VIDEO_RESOURCES)) {
2348 min_width = 48;
2349 min_height = 32;
2350
2351 /* We cannot scale up. When the scaled image is larger
2352 than crop.rect we adjust the crop.rect as required
2353 by the V4L2 spec, hence cropcap.bounds are our limit. */
2354 max_width = min(b->width, (__s32) MAX_HACTIVE);
2355 max_height = b->height;
2356
2357 /* We cannot capture the same line as video and VBI data.
2358 Note btv->vbi_end is really a minimum, see
2359 bttv_vbi_try_fmt(). */
2360 if (btv->vbi_end > b->top) {
2361 max_height -= btv->vbi_end - b->top;
2362 rc = -EBUSY;
2363 if (min_height > max_height)
2364 goto fail;
2365 }
2366 } else {
2367 rc = -EBUSY;
2368 if (btv->vbi_end > c->rect.top)
2369 goto fail;
2370
2371 min_width = c->min_scaled_width;
2372 min_height = c->min_scaled_height;
2373 max_width = c->max_scaled_width;
2374 max_height = c->max_scaled_height;
2375
2376 adjust_crop = 0;
2377 }
2378
2379 min_width = (min_width - width_mask - 1) & width_mask;
2380 max_width = max_width & width_mask;
2381
2382 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2383 min_height = min_height;
2384 /* Min. scale factor is 1:1. */
2385 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2386
2387 if (adjust_size) {
2388 *width = clamp(*width, min_width, max_width);
2389 *height = clamp(*height, min_height, max_height);
2390
2391 /* Round after clamping to avoid overflow. */
2392 *width = (*width + width_bias) & width_mask;
2393
2394 if (adjust_crop) {
2395 bttv_crop_adjust(c, b, *width, *height, field);
2396
2397 if (btv->vbi_end > c->rect.top) {
2398 /* Move the crop window out of the way. */
2399 c->rect.top = btv->vbi_end;
2400 }
2401 }
2402 } else {
2403 rc = -EINVAL;
2404 if (*width < min_width ||
2405 *height < min_height ||
2406 *width > max_width ||
2407 *height > max_height ||
2408 0 != (*width & ~width_mask))
2409 goto fail;
2410 }
2411
2412 rc = 0; /* success */
2413
2414 fail:
2415 mutex_unlock(&btv->lock);
2416
2417 return rc;
2418 }
2419
2420 /* Returns an error if the given overlay window dimensions are not
2421 possible with the current cropping parameters. If adjust_size is
2422 TRUE the function may adjust the window width and/or height
2423 instead, however it always rounds the horizontal position and
2424 width as btcx_align() does. If adjust_crop is TRUE the function
2425 may also adjust the current cropping parameters to get closer
2426 to the desired window size. */
2427 static int
2428 verify_window (struct bttv_fh * fh,
2429 struct v4l2_window * win,
2430 int adjust_size,
2431 int adjust_crop)
2432 {
2433 enum v4l2_field field;
2434 unsigned int width_mask;
2435 int rc;
2436
2437 if (win->w.width < 48 || win->w.height < 32)
2438 return -EINVAL;
2439 if (win->clipcount > 2048)
2440 return -EINVAL;
2441
2442 field = win->field;
2443
2444 if (V4L2_FIELD_ANY == field) {
2445 __s32 height2;
2446
2447 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2448 field = (win->w.height > height2)
2449 ? V4L2_FIELD_INTERLACED
2450 : V4L2_FIELD_TOP;
2451 }
2452 switch (field) {
2453 case V4L2_FIELD_TOP:
2454 case V4L2_FIELD_BOTTOM:
2455 case V4L2_FIELD_INTERLACED:
2456 break;
2457 default:
2458 return -EINVAL;
2459 }
2460
2461 /* 4-byte alignment. */
2462 if (NULL == fh->ovfmt)
2463 return -EINVAL;
2464 width_mask = ~0;
2465 switch (fh->ovfmt->depth) {
2466 case 8:
2467 case 24:
2468 width_mask = ~3;
2469 break;
2470 case 16:
2471 width_mask = ~1;
2472 break;
2473 case 32:
2474 break;
2475 default:
2476 BUG();
2477 }
2478
2479 win->w.width -= win->w.left & ~width_mask;
2480 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2481
2482 rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2483 field, width_mask,
2484 /* width_bias: round down */ 0,
2485 adjust_size, adjust_crop);
2486 if (0 != rc)
2487 return rc;
2488
2489 win->field = field;
2490 return 0;
2491 }
2492
2493 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2494 struct v4l2_window *win, int fixup)
2495 {
2496 struct v4l2_clip *clips = NULL;
2497 int n,size,retval = 0;
2498
2499 if (NULL == fh->ovfmt)
2500 return -EINVAL;
2501 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2502 return -EINVAL;
2503 retval = verify_window(fh, win,
2504 /* adjust_size */ fixup,
2505 /* adjust_crop */ fixup);
2506 if (0 != retval)
2507 return retval;
2508
2509 /* copy clips -- luckily v4l1 + v4l2 are binary
2510 compatible here ...*/
2511 n = win->clipcount;
2512 size = sizeof(*clips)*(n+4);
2513 clips = kmalloc(size,GFP_KERNEL);
2514 if (NULL == clips)
2515 return -ENOMEM;
2516 if (n > 0) {
2517 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2518 kfree(clips);
2519 return -EFAULT;
2520 }
2521 }
2522 /* clip against screen */
2523 if (NULL != btv->fbuf.base)
2524 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2525 &win->w, clips, n);
2526 btcx_sort_clips(clips,n);
2527
2528 /* 4-byte alignments */
2529 switch (fh->ovfmt->depth) {
2530 case 8:
2531 case 24:
2532 btcx_align(&win->w, clips, n, 3);
2533 break;
2534 case 16:
2535 btcx_align(&win->w, clips, n, 1);
2536 break;
2537 case 32:
2538 /* no alignment fixups needed */
2539 break;
2540 default:
2541 BUG();
2542 }
2543
2544 mutex_lock(&fh->cap.lock);
2545 kfree(fh->ov.clips);
2546 fh->ov.clips = clips;
2547 fh->ov.nclips = n;
2548
2549 fh->ov.w = win->w;
2550 fh->ov.field = win->field;
2551 fh->ov.setup_ok = 1;
2552 btv->init.ov.w.width = win->w.width;
2553 btv->init.ov.w.height = win->w.height;
2554 btv->init.ov.field = win->field;
2555
2556 /* update overlay if needed */
2557 retval = 0;
2558 if (check_btres(fh, RESOURCE_OVERLAY)) {
2559 struct bttv_buffer *new;
2560
2561 new = videobuf_alloc(sizeof(*new));
2562 new->crop = btv->crop[!!fh->do_crop].rect;
2563 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2564 retval = bttv_switch_overlay(btv,fh,new);
2565 }
2566 mutex_unlock(&fh->cap.lock);
2567 return retval;
2568 }
2569
2570 /* ----------------------------------------------------------------------- */
2571
2572 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2573 {
2574 struct videobuf_queue* q = NULL;
2575
2576 switch (fh->type) {
2577 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2578 q = &fh->cap;
2579 break;
2580 case V4L2_BUF_TYPE_VBI_CAPTURE:
2581 q = &fh->vbi;
2582 break;
2583 default:
2584 BUG();
2585 }
2586 return q;
2587 }
2588
2589 static int bttv_resource(struct bttv_fh *fh)
2590 {
2591 int res = 0;
2592
2593 switch (fh->type) {
2594 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2595 res = RESOURCE_VIDEO_STREAM;
2596 break;
2597 case V4L2_BUF_TYPE_VBI_CAPTURE:
2598 res = RESOURCE_VBI;
2599 break;
2600 default:
2601 BUG();
2602 }
2603 return res;
2604 }
2605
2606 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2607 {
2608 struct videobuf_queue *q = bttv_queue(fh);
2609 int res = bttv_resource(fh);
2610
2611 if (check_btres(fh,res))
2612 return -EBUSY;
2613 if (videobuf_queue_is_busy(q))
2614 return -EBUSY;
2615 fh->type = type;
2616 return 0;
2617 }
2618
2619 static void
2620 pix_format_set_size (struct v4l2_pix_format * f,
2621 const struct bttv_format * fmt,
2622 unsigned int width,
2623 unsigned int height)
2624 {
2625 f->width = width;
2626 f->height = height;
2627
2628 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2629 f->bytesperline = width; /* Y plane */
2630 f->sizeimage = (width * height * fmt->depth) >> 3;
2631 } else {
2632 f->bytesperline = (width * fmt->depth) >> 3;
2633 f->sizeimage = height * f->bytesperline;
2634 }
2635 }
2636
2637 static int bttv_g_fmt(struct bttv_fh *fh, struct v4l2_format *f)
2638 {
2639 switch (f->type) {
2640 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2641 memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
2642 pix_format_set_size (&f->fmt.pix, fh->fmt,
2643 fh->width, fh->height);
2644 f->fmt.pix.field = fh->cap.field;
2645 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2646 return 0;
2647 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2648 memset(&f->fmt.win,0,sizeof(struct v4l2_window));
2649 f->fmt.win.w = fh->ov.w;
2650 f->fmt.win.field = fh->ov.field;
2651 return 0;
2652 case V4L2_BUF_TYPE_VBI_CAPTURE:
2653 bttv_vbi_get_fmt(fh, &f->fmt.vbi);
2654 return 0;
2655 default:
2656 return -EINVAL;
2657 }
2658 }
2659
2660 static int bttv_try_fmt(struct bttv_fh *fh, struct bttv *btv,
2661 struct v4l2_format *f, int adjust_crop)
2662 {
2663 switch (f->type) {
2664 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2665 {
2666 const struct bttv_format *fmt;
2667 enum v4l2_field field;
2668 __s32 width, height;
2669 int rc;
2670
2671 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2672 if (NULL == fmt)
2673 return -EINVAL;
2674
2675 field = f->fmt.pix.field;
2676 if (V4L2_FIELD_ANY == field) {
2677 __s32 height2;
2678
2679 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2680 field = (f->fmt.pix.height > height2)
2681 ? V4L2_FIELD_INTERLACED
2682 : V4L2_FIELD_BOTTOM;
2683 }
2684 if (V4L2_FIELD_SEQ_BT == field)
2685 field = V4L2_FIELD_SEQ_TB;
2686 switch (field) {
2687 case V4L2_FIELD_TOP:
2688 case V4L2_FIELD_BOTTOM:
2689 case V4L2_FIELD_ALTERNATE:
2690 case V4L2_FIELD_INTERLACED:
2691 break;
2692 case V4L2_FIELD_SEQ_TB:
2693 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2694 return -EINVAL;
2695 break;
2696 default:
2697 return -EINVAL;
2698 }
2699
2700 width = f->fmt.pix.width;
2701 height = f->fmt.pix.height;
2702
2703 rc = limit_scaled_size(fh, &width, &height, field,
2704 /* width_mask: 4 pixels */ ~3,
2705 /* width_bias: nearest */ 2,
2706 /* adjust_size */ 1,
2707 adjust_crop);
2708 if (0 != rc)
2709 return rc;
2710
2711 /* update data for the application */
2712 f->fmt.pix.field = field;
2713 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2714
2715 return 0;
2716 }
2717 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2718 return verify_window(fh, &f->fmt.win,
2719 /* adjust_size */ 1,
2720 /* adjust_crop */ 0);
2721 case V4L2_BUF_TYPE_VBI_CAPTURE:
2722 return bttv_vbi_try_fmt(fh, &f->fmt.vbi);
2723 default:
2724 return -EINVAL;
2725 }
2726 }
2727
2728 static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
2729 struct v4l2_format *f)
2730 {
2731 int retval;
2732
2733 switch (f->type) {
2734 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2735 {
2736 const struct bttv_format *fmt;
2737
2738 retval = bttv_switch_type(fh,f->type);
2739 if (0 != retval)
2740 return retval;
2741 retval = bttv_try_fmt(fh,btv,f, /* adjust_crop */ 1);
2742 if (0 != retval)
2743 return retval;
2744 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2745
2746 /* update our state informations */
2747 mutex_lock(&fh->cap.lock);
2748 fh->fmt = fmt;
2749 fh->cap.field = f->fmt.pix.field;
2750 fh->cap.last = V4L2_FIELD_NONE;
2751 fh->width = f->fmt.pix.width;
2752 fh->height = f->fmt.pix.height;
2753 btv->init.fmt = fmt;
2754 btv->init.width = f->fmt.pix.width;
2755 btv->init.height = f->fmt.pix.height;
2756 mutex_unlock(&fh->cap.lock);
2757
2758 return 0;
2759 }
2760 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2761 if (no_overlay > 0) {
2762 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2763 return -EINVAL;
2764 }
2765 return setup_window(fh, btv, &f->fmt.win, 1);
2766 case V4L2_BUF_TYPE_VBI_CAPTURE:
2767 retval = bttv_switch_type(fh,f->type);
2768 if (0 != retval)
2769 return retval;
2770 return bttv_vbi_set_fmt(fh, &f->fmt.vbi);
2771 default:
2772 return -EINVAL;
2773 }
2774 }
2775
2776 static int bttv_do_ioctl(struct inode *inode, struct file *file,
2777 unsigned int cmd, void *arg)
2778 {
2779 struct bttv_fh *fh = file->private_data;
2780 struct bttv *btv = fh->btv;
2781 unsigned long flags;
2782 int retval = 0;
2783
2784 if (bttv_debug > 1)
2785 v4l_print_ioctl(btv->c.name, cmd);
2786
2787 if (btv->errors)
2788 bttv_reinit_bt848(btv);
2789
2790 switch (cmd) {
2791 case VIDIOCSFREQ:
2792 case VIDIOCSTUNER:
2793 case VIDIOCSCHAN:
2794 case VIDIOC_S_CTRL:
2795 case VIDIOC_S_STD:
2796 case VIDIOC_S_INPUT:
2797 case VIDIOC_S_TUNER:
2798 case VIDIOC_S_FREQUENCY:
2799 retval = v4l2_prio_check(&btv->prio,&fh->prio);
2800 if (0 != retval)
2801 return retval;
2802 };
2803
2804 switch (cmd) {
2805
2806 /* *** v4l1 *** ************************************************ */
2807 case VIDIOCGCAP:
2808 {
2809 struct video_capability *cap = arg;
2810
2811 memset(cap,0,sizeof(*cap));
2812 strcpy(cap->name,btv->video_dev->name);
2813 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2814 /* vbi */
2815 cap->type = VID_TYPE_TUNER|VID_TYPE_TELETEXT;
2816 } else {
2817 /* others */
2818 cap->type = VID_TYPE_CAPTURE|
2819 VID_TYPE_TUNER|
2820 VID_TYPE_CLIPPING|
2821 VID_TYPE_SCALES;
2822 if (no_overlay <= 0)
2823 cap->type |= VID_TYPE_OVERLAY;
2824
2825 cap->maxwidth = bttv_tvnorms[btv->tvnorm].swidth;
2826 cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
2827 cap->minwidth = 48;
2828 cap->minheight = 32;
2829 }
2830 cap->channels = bttv_tvcards[btv->c.type].video_inputs;
2831 cap->audios = bttv_tvcards[btv->c.type].audio_inputs;
2832 return 0;
2833 }
2834
2835 case VIDIOCGPICT:
2836 {
2837 struct video_picture *pic = arg;
2838
2839 memset(pic,0,sizeof(*pic));
2840 pic->brightness = btv->bright;
2841 pic->contrast = btv->contrast;
2842 pic->hue = btv->hue;
2843 pic->colour = btv->saturation;
2844 if (fh->fmt) {
2845 pic->depth = fh->fmt->depth;
2846 pic->palette = fh->fmt->palette;
2847 }
2848 return 0;
2849 }
2850 case VIDIOCSPICT:
2851 {
2852 struct video_picture *pic = arg;
2853 const struct bttv_format *fmt;
2854
2855 fmt = format_by_palette(pic->palette);
2856 if (NULL == fmt)
2857 return -EINVAL;
2858 mutex_lock(&fh->cap.lock);
2859 if (fmt->depth != pic->depth) {
2860 retval = -EINVAL;
2861 goto fh_unlock_and_return;
2862 }
2863 if (fmt->flags & FORMAT_FLAGS_RAW) {
2864 /* VIDIOCMCAPTURE uses gbufsize, not RAW_BPL *
2865 RAW_LINES * 2. F1 is stored at offset 0, F2
2866 at buffer size / 2. */
2867 fh->width = RAW_BPL;
2868 fh->height = gbufsize / RAW_BPL;
2869 btv->init.width = RAW_BPL;
2870 btv->init.height = gbufsize / RAW_BPL;
2871 }
2872 fh->ovfmt = fmt;
2873 fh->fmt = fmt;
2874 btv->init.ovfmt = fmt;
2875 btv->init.fmt = fmt;
2876 if (bigendian) {
2877 /* dirty hack time: swap bytes for overlay if the
2878 display adaptor is big endian (insmod option) */
2879 if (fmt->palette == VIDEO_PALETTE_RGB555 ||
2880 fmt->palette == VIDEO_PALETTE_RGB565 ||
2881 fmt->palette == VIDEO_PALETTE_RGB32) {
2882 fh->ovfmt = fmt+1;
2883 }
2884 }
2885 bt848_bright(btv,pic->brightness);
2886 bt848_contrast(btv,pic->contrast);
2887 bt848_hue(btv,pic->hue);
2888 bt848_sat(btv,pic->colour);
2889 mutex_unlock(&fh->cap.lock);
2890 return 0;
2891 }
2892
2893 case VIDIOCGWIN:
2894 {
2895 struct video_window *win = arg;
2896
2897 memset(win,0,sizeof(*win));
2898 win->x = fh->ov.w.left;
2899 win->y = fh->ov.w.top;
2900 win->width = fh->ov.w.width;
2901 win->height = fh->ov.w.height;
2902 return 0;
2903 }
2904 case VIDIOCSWIN:
2905 {
2906 struct video_window *win = arg;
2907 struct v4l2_window w2;
2908
2909 if (no_overlay > 0) {
2910 printk ("VIDIOCSWIN: no_overlay\n");
2911 return -EINVAL;
2912 }
2913
2914 w2.field = V4L2_FIELD_ANY;
2915 w2.w.left = win->x;
2916 w2.w.top = win->y;
2917 w2.w.width = win->width;
2918 w2.w.height = win->height;
2919 w2.clipcount = win->clipcount;
2920 w2.clips = (struct v4l2_clip __user *)win->clips;
2921 retval = setup_window(fh, btv, &w2, 0);
2922 if (0 == retval) {
2923 /* on v4l1 this ioctl affects the read() size too */
2924 fh->width = fh->ov.w.width;
2925 fh->height = fh->ov.w.height;
2926 btv->init.width = fh->ov.w.width;
2927 btv->init.height = fh->ov.w.height;
2928 }
2929 return retval;
2930 }
2931
2932 case VIDIOCGFBUF:
2933 {
2934 struct video_buffer *fbuf = arg;
2935
2936 fbuf->base = btv->fbuf.base;
2937 fbuf->width = btv->fbuf.fmt.width;
2938 fbuf->height = btv->fbuf.fmt.height;
2939 fbuf->bytesperline = btv->fbuf.fmt.bytesperline;
2940 if (fh->ovfmt)
2941 fbuf->depth = fh->ovfmt->depth;
2942 else {
2943 if (fbuf->width)
2944 fbuf->depth = ((fbuf->bytesperline<<3)
2945 + (fbuf->width-1) )
2946 /fbuf->width;
2947 else
2948 fbuf->depth = 0;
2949 }
2950 return 0;
2951 }
2952 case VIDIOCSFBUF:
2953 {
2954 struct video_buffer *fbuf = arg;
2955 const struct bttv_format *fmt;
2956 unsigned long end;
2957
2958 if(!capable(CAP_SYS_ADMIN) &&
2959 !capable(CAP_SYS_RAWIO))
2960 return -EPERM;
2961 end = (unsigned long)fbuf->base +
2962 fbuf->height * fbuf->bytesperline;
2963 mutex_lock(&fh->cap.lock);
2964 retval = -EINVAL;
2965
2966 switch (fbuf->depth) {
2967 case 8:
2968 fmt = format_by_palette(VIDEO_PALETTE_HI240);
2969 break;
2970 case 16:
2971 fmt = format_by_palette(VIDEO_PALETTE_RGB565);
2972 break;
2973 case 24:
2974 fmt = format_by_palette(VIDEO_PALETTE_RGB24);
2975 break;
2976 case 32:
2977 fmt = format_by_palette(VIDEO_PALETTE_RGB32);
2978 break;
2979 case 15:
2980 fbuf->depth = 16;
2981 fmt = format_by_palette(VIDEO_PALETTE_RGB555);
2982 break;
2983 default:
2984 fmt = NULL;
2985 break;
2986 }
2987 if (NULL == fmt)
2988 goto fh_unlock_and_return;
2989
2990 fh->ovfmt = fmt;
2991 fh->fmt = fmt;
2992 btv->init.ovfmt = fmt;
2993 btv->init.fmt = fmt;
2994 btv->fbuf.base = fbuf->base;
2995 btv->fbuf.fmt.width = fbuf->width;
2996 btv->fbuf.fmt.height = fbuf->height;
2997 if (fbuf->bytesperline)
2998 btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
2999 else
3000 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
3001 mutex_unlock(&fh->cap.lock);
3002 return 0;
3003 }
3004
3005 case VIDIOCCAPTURE:
3006 case VIDIOC_OVERLAY:
3007 {
3008 struct bttv_buffer *new;
3009 int *on = arg;
3010
3011 if (*on) {
3012 /* verify args */
3013 if (NULL == btv->fbuf.base)
3014 return -EINVAL;
3015 if (!fh->ov.setup_ok) {
3016 dprintk("bttv%d: overlay: !setup_ok\n",btv->c.nr);
3017 return -EINVAL;
3018 }
3019 }
3020
3021 if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
3022 return -EBUSY;
3023
3024 mutex_lock(&fh->cap.lock);
3025 if (*on) {
3026 fh->ov.tvnorm = btv->tvnorm;
3027 new = videobuf_alloc(sizeof(*new));
3028 new->crop = btv->crop[!!fh->do_crop].rect;
3029 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
3030 } else {
3031 new = NULL;
3032 }
3033
3034 /* switch over */
3035 retval = bttv_switch_overlay(btv,fh,new);
3036 mutex_unlock(&fh->cap.lock);
3037 return retval;
3038 }
3039
3040 case VIDIOCGMBUF:
3041 {
3042 struct video_mbuf *mbuf = arg;
3043 unsigned int i;
3044
3045 mutex_lock(&fh->cap.lock);
3046 retval = videobuf_mmap_setup(&fh->cap,gbuffers,gbufsize,
3047 V4L2_MEMORY_MMAP);
3048 if (retval < 0)
3049 goto fh_unlock_and_return;
3050 memset(mbuf,0,sizeof(*mbuf));
3051 mbuf->frames = gbuffers;
3052 mbuf->size = gbuffers * gbufsize;
3053 for (i = 0; i < gbuffers; i++)
3054 mbuf->offsets[i] = i * gbufsize;
3055 mutex_unlock(&fh->cap.lock);
3056 return 0;
3057 }
3058 case VIDIOCMCAPTURE:
3059 {
3060 struct video_mmap *vm = arg;
3061 struct bttv_buffer *buf;
3062 enum v4l2_field field;
3063 __s32 height2;
3064 int res;
3065
3066 if (vm->frame >= VIDEO_MAX_FRAME)
3067 return -EINVAL;
3068
3069 res = bttv_resource(fh);
3070 if (!check_alloc_btres(btv, fh, res))
3071 return -EBUSY;
3072
3073 mutex_lock(&fh->cap.lock);
3074 retval = -EINVAL;
3075 buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
3076 if (NULL == buf)
3077 goto fh_unlock_and_return;
3078 if (0 == buf->vb.baddr)
3079 goto fh_unlock_and_return;
3080 if (buf->vb.state == STATE_QUEUED ||
3081 buf->vb.state == STATE_ACTIVE)
3082 goto fh_unlock_and_return;
3083
3084 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
3085 field = (vm->height > height2)
3086 ? V4L2_FIELD_INTERLACED
3087 : V4L2_FIELD_BOTTOM;
3088 retval = bttv_prepare_buffer(&fh->cap,btv,buf,
3089 format_by_palette(vm->format),
3090 vm->width,vm->height,field);
3091 if (0 != retval)
3092 goto fh_unlock_and_return;
3093 spin_lock_irqsave(&btv->s_lock,flags);
3094 buffer_queue(&fh->cap,&buf->vb);
3095 spin_unlock_irqrestore(&btv->s_lock,flags);
3096 mutex_unlock(&fh->cap.lock);
3097 return 0;
3098 }
3099 case VIDIOCSYNC:
3100 {
3101 int *frame = arg;
3102 struct bttv_buffer *buf;
3103
3104 if (*frame >= VIDEO_MAX_FRAME)
3105 return -EINVAL;
3106
3107 mutex_lock(&fh->cap.lock);
3108 retval = -EINVAL;
3109 buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
3110 if (NULL == buf)
3111 goto fh_unlock_and_return;
3112 retval = videobuf_waiton(&buf->vb,0,1);
3113 if (0 != retval)
3114 goto fh_unlock_and_return;
3115 switch (buf->vb.state) {
3116 case STATE_ERROR:
3117 retval = -EIO;
3118 /* fall through */
3119 case STATE_DONE:
3120 videobuf_dma_sync(&fh->cap,&buf->vb.dma);
3121 bttv_dma_free(&fh->cap,btv,buf);
3122 break;
3123 default:
3124 retval = -EINVAL;
3125 break;
3126 }
3127 mutex_unlock(&fh->cap.lock);
3128 return retval;
3129 }
3130
3131 case VIDIOCGVBIFMT:
3132 if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
3133 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
3134 if (0 != retval)
3135 return retval;
3136 }
3137
3138 /* fall through */
3139
3140 case VIDIOCSVBIFMT:
3141 return v4l_compat_translate_ioctl(inode, file, cmd,
3142 arg, bttv_do_ioctl);
3143
3144 case BTTV_VERSION:
3145 case VIDIOCGFREQ:
3146 case VIDIOCSFREQ:
3147 case VIDIOCGTUNER:
3148 case VIDIOCSTUNER:
3149 case VIDIOCGCHAN:
3150 case VIDIOCSCHAN:
3151 case VIDIOCGAUDIO:
3152 case VIDIOCSAUDIO:
3153 return bttv_common_ioctls(btv,cmd,arg);
3154
3155 /* *** v4l2 *** ************************************************ */
3156 case VIDIOC_QUERYCAP:
3157 {
3158 struct v4l2_capability *cap = arg;
3159
3160 if (0 == v4l2)
3161 return -EINVAL;
3162 memset(cap, 0, sizeof (*cap));
3163 strlcpy(cap->driver, "bttv", sizeof (cap->driver));
3164 strlcpy(cap->card, btv->video_dev->name, sizeof (cap->card));
3165 snprintf(cap->bus_info, sizeof (cap->bus_info),
3166 "PCI:%s", pci_name(btv->c.pci));
3167 cap->version = BTTV_VERSION_CODE;
3168 cap->capabilities =
3169 V4L2_CAP_VIDEO_CAPTURE |
3170 V4L2_CAP_VBI_CAPTURE |
3171 V4L2_CAP_READWRITE |
3172 V4L2_CAP_STREAMING;
3173 if (no_overlay <= 0)
3174 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
3175
3176 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
3177 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
3178 cap->capabilities |= V4L2_CAP_TUNER;
3179 return 0;
3180 }
3181
3182 case VIDIOC_ENUM_FMT:
3183 {
3184 struct v4l2_fmtdesc *f = arg;
3185 enum v4l2_buf_type type;
3186 unsigned int i;
3187 int index;
3188
3189 type = f->type;
3190 if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
3191 /* vbi */
3192 index = f->index;
3193 if (0 != index)
3194 return -EINVAL;
3195 memset(f,0,sizeof(*f));
3196 f->index = index;
3197 f->type = type;
3198 f->pixelformat = V4L2_PIX_FMT_GREY;
3199 strcpy(f->description,"vbi data");
3200 return 0;
3201 }
3202
3203 /* video capture + overlay */
3204 index = -1;
3205 for (i = 0; i < BTTV_FORMATS; i++) {
3206 if (bttv_formats[i].fourcc != -1)
3207 index++;
3208 if ((unsigned int)index == f->index)
3209 break;
3210 }
3211 if (BTTV_FORMATS == i)
3212 return -EINVAL;
3213
3214 switch (f->type) {
3215 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3216 break;
3217 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
3218 if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
3219 return -EINVAL;
3220 break;
3221 default:
3222 return -EINVAL;
3223 }
3224 memset(f,0,sizeof(*f));
3225 f->index = index;
3226 f->type = type;
3227 f->pixelformat = bttv_formats[i].fourcc;
3228 strlcpy(f->description,bttv_formats[i].name,sizeof(f->description));
3229 return 0;
3230 }
3231
3232 case VIDIOC_TRY_FMT:
3233 {
3234 struct v4l2_format *f = arg;
3235 return bttv_try_fmt(fh,btv,f, /* adjust_crop */ 0);
3236 }
3237 case VIDIOC_G_FMT:
3238 {
3239 struct v4l2_format *f = arg;
3240 return bttv_g_fmt(fh,f);
3241 }
3242 case VIDIOC_S_FMT:
3243 {
3244 struct v4l2_format *f = arg;
3245 return bttv_s_fmt(fh,btv,f);
3246 }
3247
3248 case VIDIOC_G_FBUF:
3249 {
3250 struct v4l2_framebuffer *fb = arg;
3251
3252 *fb = btv->fbuf;
3253 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
3254 if (fh->ovfmt)
3255 fb->fmt.pixelformat = fh->ovfmt->fourcc;
3256 return 0;
3257 }
3258 case VIDIOC_S_FBUF:
3259 {
3260 struct v4l2_framebuffer *fb = arg;
3261 const struct bttv_format *fmt;
3262
3263 if(!capable(CAP_SYS_ADMIN) &&
3264 !capable(CAP_SYS_RAWIO))
3265 return -EPERM;
3266
3267 /* check args */
3268 fmt = format_by_fourcc(fb->fmt.pixelformat);
3269 if (NULL == fmt)
3270 return -EINVAL;
3271 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
3272 return -EINVAL;
3273
3274 retval = -EINVAL;
3275 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
3276 __s32 width = fb->fmt.width;
3277 __s32 height = fb->fmt.height;
3278
3279 retval = limit_scaled_size(fh, &width, &height,
3280 V4L2_FIELD_INTERLACED,
3281 /* width_mask */ ~3,
3282 /* width_bias */ 2,
3283 /* adjust_size */ 0,
3284 /* adjust_crop */ 0);
3285 if (0 != retval)
3286 return retval;
3287 }
3288
3289 /* ok, accept it */
3290 mutex_lock(&fh->cap.lock);
3291 btv->fbuf.base = fb->base;
3292 btv->fbuf.fmt.width = fb->fmt.width;
3293 btv->fbuf.fmt.height = fb->fmt.height;
3294 if (0 != fb->fmt.bytesperline)
3295 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
3296 else
3297 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
3298
3299 retval = 0;
3300 fh->ovfmt = fmt;
3301 btv->init.ovfmt = fmt;
3302 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
3303 fh->ov.w.left = 0;
3304 fh->ov.w.top = 0;
3305 fh->ov.w.width = fb->fmt.width;
3306 fh->ov.w.height = fb->fmt.height;
3307 btv->init.ov.w.width = fb->fmt.width;
3308 btv->init.ov.w.height = fb->fmt.height;
3309 kfree(fh->ov.clips);
3310 fh->ov.clips = NULL;
3311 fh->ov.nclips = 0;
3312
3313 if (check_btres(fh, RESOURCE_OVERLAY)) {
3314 struct bttv_buffer *new;
3315
3316 new = videobuf_alloc(sizeof(*new));
3317 new->crop = btv->crop[!!fh->do_crop].rect;
3318 bttv_overlay_risc(btv,&fh->ov,fh->ovfmt,new);
3319 retval = bttv_switch_overlay(btv,fh,new);
3320 }
3321 }
3322 mutex_unlock(&fh->cap.lock);
3323 return retval;
3324 }
3325
3326 case VIDIOC_REQBUFS:
3327 return videobuf_reqbufs(bttv_queue(fh),arg);
3328
3329 case VIDIOC_QUERYBUF:
3330 return videobuf_querybuf(bttv_queue(fh),arg);
3331
3332 case VIDIOC_QBUF:
3333 {
3334 int res = bttv_resource(fh);
3335
3336 if (!check_alloc_btres(btv, fh, res))
3337 return -EBUSY;
3338 return videobuf_qbuf(bttv_queue(fh),arg);
3339 }
3340
3341 case VIDIOC_DQBUF:
3342 return videobuf_dqbuf(bttv_queue(fh),arg,
3343 file->f_flags & O_NONBLOCK);
3344
3345 case VIDIOC_STREAMON:
3346 {
3347 int res = bttv_resource(fh);
3348
3349 if (!check_alloc_btres(btv,fh,res))
3350 return -EBUSY;
3351 return videobuf_streamon(bttv_queue(fh));
3352 }
3353 case VIDIOC_STREAMOFF:
3354 {
3355 int res = bttv_resource(fh);
3356
3357 retval = videobuf_streamoff(bttv_queue(fh));
3358 if (retval < 0)
3359 return retval;
3360 free_btres(btv,fh,res);
3361 return 0;
3362 }
3363
3364 case VIDIOC_QUERYCTRL:
3365 {
3366 struct v4l2_queryctrl *c = arg;
3367 int i;
3368
3369 if ((c->id < V4L2_CID_BASE ||
3370 c->id >= V4L2_CID_LASTP1) &&
3371 (c->id < V4L2_CID_PRIVATE_BASE ||
3372 c->id >= V4L2_CID_PRIVATE_LASTP1))
3373 return -EINVAL;
3374 for (i = 0; i < BTTV_CTLS; i++)
3375 if (bttv_ctls[i].id == c->id)
3376 break;
3377 if (i == BTTV_CTLS) {
3378 *c = no_ctl;
3379 return 0;
3380 }
3381 *c = bttv_ctls[i];
3382 if (btv->audio_hook && i >= 4 && i <= 8) {
3383 struct video_audio va;
3384 memset(&va,0,sizeof(va));
3385 btv->audio_hook(btv,&va,0);
3386 switch (bttv_ctls[i].id) {
3387 case V4L2_CID_AUDIO_VOLUME:
3388 if (!(va.flags & VIDEO_AUDIO_VOLUME))
3389 *c = no_ctl;
3390 break;
3391 case V4L2_CID_AUDIO_BALANCE:
3392 if (!(va.flags & VIDEO_AUDIO_BALANCE))
3393 *c = no_ctl;
3394 break;
3395 case V4L2_CID_AUDIO_BASS:
3396 if (!(va.flags & VIDEO_AUDIO_BASS))
3397 *c = no_ctl;
3398 break;
3399 case V4L2_CID_AUDIO_TREBLE:
3400 if (!(va.flags & VIDEO_AUDIO_TREBLE))
3401 *c = no_ctl;
3402 break;
3403 }
3404 }
3405 return 0;
3406 }
3407 case VIDIOC_G_CTRL:
3408 return get_control(btv,arg);
3409 case VIDIOC_S_CTRL:
3410 return set_control(btv,arg);
3411 case VIDIOC_G_PARM:
3412 {
3413 struct v4l2_streamparm *parm = arg;
3414 struct v4l2_standard s;
3415 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
3416 return -EINVAL;
3417 memset(parm,0,sizeof(*parm));
3418 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
3419 bttv_tvnorms[btv->tvnorm].name);
3420 parm->parm.capture.timeperframe = s.frameperiod;
3421 return 0;
3422 }
3423
3424 case VIDIOC_G_PRIORITY:
3425 {
3426 enum v4l2_priority *p = arg;
3427
3428 *p = v4l2_prio_max(&btv->prio);
3429 return 0;
3430 }
3431 case VIDIOC_S_PRIORITY:
3432 {
3433 enum v4l2_priority *prio = arg;
3434
3435 return v4l2_prio_change(&btv->prio, &fh->prio, *prio);
3436 }
3437
3438 case VIDIOC_CROPCAP:
3439 {
3440 struct v4l2_cropcap *cap = arg;
3441 enum v4l2_buf_type type;
3442
3443 type = cap->type;
3444
3445 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3446 type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3447 return -EINVAL;
3448
3449 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3450 cap->type = type;
3451
3452 return 0;
3453 }
3454 case VIDIOC_G_CROP:
3455 {
3456 struct v4l2_crop * crop = arg;
3457
3458 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3459 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3460 return -EINVAL;
3461
3462 /* No fh->do_crop = 1; because btv->crop[1] may be
3463 inconsistent with fh->width or fh->height and apps
3464 do not expect a change here. */
3465
3466 crop->c = btv->crop[!!fh->do_crop].rect;
3467
3468 return 0;
3469 }
3470 case VIDIOC_S_CROP:
3471 {
3472 struct v4l2_crop *crop = arg;
3473 const struct v4l2_rect *b;
3474 struct bttv_crop c;
3475 __s32 b_left;
3476 __s32 b_top;
3477 __s32 b_right;
3478 __s32 b_bottom;
3479
3480 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3481 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3482 return -EINVAL;
3483
3484 retval = v4l2_prio_check(&btv->prio,&fh->prio);
3485 if (0 != retval)
3486 return retval;
3487
3488 /* Make sure tvnorm, vbi_end and the current cropping
3489 parameters remain consistent until we're done. Note
3490 read() may change vbi_end in check_alloc_btres(). */
3491 mutex_lock(&btv->lock);
3492
3493 retval = -EBUSY;
3494
3495 if (locked_btres(fh->btv, VIDEO_RESOURCES))
3496 goto btv_unlock_and_return;
3497
3498 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3499
3500 b_left = b->left;
3501 b_right = b_left + b->width;
3502 b_bottom = b->top + b->height;
3503
3504 b_top = max(b->top, btv->vbi_end);
3505 if (b_top + 32 >= b_bottom)
3506 goto btv_unlock_and_return;
3507
3508 /* Min. scaled size 48 x 32. */
3509 c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3510 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3511
3512 c.rect.width = clamp(crop->c.width,
3513 48, b_right - c.rect.left);
3514
3515 c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3516 /* Top and height must be a multiple of two. */
3517 c.rect.top = (c.rect.top + 1) & ~1;
3518
3519 c.rect.height = clamp(crop->c.height,
3520 32, b_bottom - c.rect.top);
3521 c.rect.height = (c.rect.height + 1) & ~1;
3522
3523 bttv_crop_calc_limits(&c);
3524
3525 btv->crop[1] = c;
3526
3527 mutex_unlock(&btv->lock);
3528
3529 fh->do_crop = 1;
3530
3531 mutex_lock(&fh->cap.lock);
3532
3533 if (fh->width < c.min_scaled_width) {
3534 fh->width = c.min_scaled_width;
3535 btv->init.width = c.min_scaled_width;
3536 } else if (fh->width > c.max_scaled_width) {
3537 fh->width = c.max_scaled_width;
3538 btv->init.width = c.max_scaled_width;
3539 }
3540
3541 if (fh->height < c.min_scaled_height) {
3542 fh->height = c.min_scaled_height;
3543 btv->init.height = c.min_scaled_height;
3544 } else if (fh->height > c.max_scaled_height) {
3545 fh->height = c.max_scaled_height;
3546 btv->init.height = c.max_scaled_height;
3547 }
3548
3549 mutex_unlock(&fh->cap.lock);
3550
3551 return 0;
3552 }
3553
3554 case VIDIOC_ENUMSTD:
3555 case VIDIOC_G_STD:
3556 case VIDIOC_S_STD:
3557 case VIDIOC_ENUMINPUT:
3558 case VIDIOC_G_INPUT:
3559 case VIDIOC_S_INPUT:
3560 case VIDIOC_G_TUNER:
3561 case VIDIOC_S_TUNER:
3562 case VIDIOC_G_FREQUENCY:
3563 case VIDIOC_S_FREQUENCY:
3564 case VIDIOC_LOG_STATUS:
3565 return bttv_common_ioctls(btv,cmd,arg);
3566
3567 default:
3568 return -ENOIOCTLCMD;
3569 }
3570 return 0;
3571
3572 fh_unlock_and_return:
3573 mutex_unlock(&fh->cap.lock);
3574 return retval;
3575
3576 btv_unlock_and_return:
3577 mutex_unlock(&btv->lock);
3578 return retval;
3579 }
3580
3581 static int bttv_ioctl(struct inode *inode, struct file *file,
3582 unsigned int cmd, unsigned long arg)
3583 {
3584 struct bttv_fh *fh = file->private_data;
3585
3586 switch (cmd) {
3587 case BTTV_VBISIZE:
3588 {
3589 const struct bttv_tvnorm *tvnorm;
3590
3591 tvnorm = fh->vbi_fmt.tvnorm;
3592
3593 if (fh->vbi_fmt.fmt.start[0] != tvnorm->vbistart[0] ||
3594 fh->vbi_fmt.fmt.start[1] != tvnorm->vbistart[1] ||
3595 fh->vbi_fmt.fmt.count[0] != fh->vbi_fmt.fmt.count[1]) {
3596 /* BTTV_VBISIZE cannot express these parameters,
3597 however open() resets the paramters to defaults
3598 and apps shouldn't call BTTV_VBISIZE after
3599 VIDIOC_S_FMT. */
3600 return -EINVAL;
3601 }
3602
3603 bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
3604 return (fh->vbi_fmt.fmt.count[0] * 2
3605 * fh->vbi_fmt.fmt.samples_per_line);
3606 }
3607
3608 default:
3609 return video_usercopy(inode, file, cmd, arg, bttv_do_ioctl);
3610 }
3611 }
3612
3613 static ssize_t bttv_read(struct file *file, char __user *data,
3614 size_t count, loff_t *ppos)
3615 {
3616 struct bttv_fh *fh = file->private_data;
3617 int retval = 0;
3618
3619 if (fh->btv->errors)
3620 bttv_reinit_bt848(fh->btv);
3621 dprintk("bttv%d: read count=%d type=%s\n",
3622 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3623
3624 switch (fh->type) {
3625 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3626 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3627 /* VIDEO_READ in use by another fh,
3628 or VIDEO_STREAM by any fh. */
3629 return -EBUSY;
3630 }
3631 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3632 file->f_flags & O_NONBLOCK);
3633 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3634 break;
3635 case V4L2_BUF_TYPE_VBI_CAPTURE:
3636 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3637 return -EBUSY;
3638 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3639 file->f_flags & O_NONBLOCK);
3640 break;
3641 default:
3642 BUG();
3643 }
3644 return retval;
3645 }
3646
3647 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3648 {
3649 struct bttv_fh *fh = file->private_data;
3650 struct bttv_buffer *buf;
3651 enum v4l2_field field;
3652
3653 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3654 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3655 return POLLERR;
3656 return videobuf_poll_stream(file, &fh->vbi, wait);
3657 }
3658
3659 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3660 /* streaming capture */
3661 if (list_empty(&fh->cap.stream))
3662 return POLLERR;
3663 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3664 } else {
3665 /* read() capture */
3666 mutex_lock(&fh->cap.lock);
3667 if (NULL == fh->cap.read_buf) {
3668 /* need to capture a new frame */
3669 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM)) {
3670 mutex_unlock(&fh->cap.lock);
3671 return POLLERR;
3672 }
3673 fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
3674 if (NULL == fh->cap.read_buf) {
3675 mutex_unlock(&fh->cap.lock);
3676 return POLLERR;
3677 }
3678 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3679 field = videobuf_next_field(&fh->cap);
3680 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3681 kfree (fh->cap.read_buf);
3682 fh->cap.read_buf = NULL;
3683 mutex_unlock(&fh->cap.lock);
3684 return POLLERR;
3685 }
3686 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3687 fh->cap.read_off = 0;
3688 }
3689 mutex_unlock(&fh->cap.lock);
3690 buf = (struct bttv_buffer*)fh->cap.read_buf;
3691 }
3692
3693 poll_wait(file, &buf->vb.done, wait);
3694 if (buf->vb.state == STATE_DONE ||
3695 buf->vb.state == STATE_ERROR)
3696 return POLLIN|POLLRDNORM;
3697 return 0;
3698 }
3699
3700 static int bttv_open(struct inode *inode, struct file *file)
3701 {
3702 int minor = iminor(inode);
3703 struct bttv *btv = NULL;
3704 struct bttv_fh *fh;
3705 enum v4l2_buf_type type = 0;
3706 unsigned int i;
3707
3708 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3709
3710 for (i = 0; i < bttv_num; i++) {
3711 if (bttvs[i].video_dev &&
3712 bttvs[i].video_dev->minor == minor) {
3713 btv = &bttvs[i];
3714 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3715 break;
3716 }
3717 if (bttvs[i].vbi_dev &&
3718 bttvs[i].vbi_dev->minor == minor) {
3719 btv = &bttvs[i];
3720 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3721 break;
3722 }
3723 }
3724 if (NULL == btv)
3725 return -ENODEV;
3726
3727 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3728 btv->c.nr,v4l2_type_names[type]);
3729
3730 /* allocate per filehandle data */
3731 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3732 if (NULL == fh)
3733 return -ENOMEM;
3734 file->private_data = fh;
3735 *fh = btv->init;
3736 fh->type = type;
3737 fh->ov.setup_ok = 0;
3738 v4l2_prio_open(&btv->prio,&fh->prio);
3739
3740 videobuf_queue_init(&fh->cap, &bttv_video_qops,
3741 btv->c.pci, &btv->s_lock,
3742 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3743 V4L2_FIELD_INTERLACED,
3744 sizeof(struct bttv_buffer),
3745 fh);
3746 videobuf_queue_init(&fh->vbi, &bttv_vbi_qops,
3747 btv->c.pci, &btv->s_lock,
3748 V4L2_BUF_TYPE_VBI_CAPTURE,
3749 V4L2_FIELD_SEQ_TB,
3750 sizeof(struct bttv_buffer),
3751 fh);
3752 i2c_vidiocschan(btv);
3753
3754 btv->users++;
3755
3756 /* The V4L2 spec requires one global set of cropping parameters
3757 which only change on request. These are stored in btv->crop[1].
3758 However for compatibility with V4L apps and cropping unaware
3759 V4L2 apps we now reset the cropping parameters as seen through
3760 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3761 will use btv->crop[0], the default cropping parameters for the
3762 current video standard, and VIDIOC_S_FMT will not implicitely
3763 change the cropping parameters until VIDIOC_S_CROP has been
3764 called. */
3765 fh->do_crop = !reset_crop; /* module parameter */
3766
3767 /* Likewise there should be one global set of VBI capture
3768 parameters, but for compatibility with V4L apps and earlier
3769 driver versions each fh has its own parameters. */
3770 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3771
3772 bttv_field_count(btv);
3773 return 0;
3774 }
3775
3776 static int bttv_release(struct inode *inode, struct file *file)
3777 {
3778 struct bttv_fh *fh = file->private_data;
3779 struct bttv *btv = fh->btv;
3780
3781 /* turn off overlay */
3782 if (check_btres(fh, RESOURCE_OVERLAY))
3783 bttv_switch_overlay(btv,fh,NULL);
3784
3785 /* stop video capture */
3786 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3787 videobuf_streamoff(&fh->cap);
3788 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3789 }
3790 if (fh->cap.read_buf) {
3791 buffer_release(&fh->cap,fh->cap.read_buf);
3792 kfree(fh->cap.read_buf);
3793 }
3794 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3795 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3796 }
3797
3798 /* stop vbi capture */
3799 if (check_btres(fh, RESOURCE_VBI)) {
3800 if (fh->vbi.streaming)
3801 videobuf_streamoff(&fh->vbi);
3802 if (fh->vbi.reading)
3803 videobuf_read_stop(&fh->vbi);
3804 free_btres(btv,fh,RESOURCE_VBI);
3805 }
3806
3807 /* free stuff */
3808 videobuf_mmap_free(&fh->cap);
3809 videobuf_mmap_free(&fh->vbi);
3810 v4l2_prio_close(&btv->prio,&fh->prio);
3811 file->private_data = NULL;
3812 kfree(fh);
3813
3814 btv->users--;
3815 bttv_field_count(btv);
3816 return 0;
3817 }
3818
3819 static int
3820 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3821 {
3822 struct bttv_fh *fh = file->private_data;
3823
3824 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3825 fh->btv->c.nr, v4l2_type_names[fh->type],
3826 vma->vm_start, vma->vm_end - vma->vm_start);
3827 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3828 }
3829
3830 static const struct file_operations bttv_fops =
3831 {
3832 .owner = THIS_MODULE,
3833 .open = bttv_open,
3834 .release = bttv_release,
3835 .ioctl = bttv_ioctl,
3836 .compat_ioctl = v4l_compat_ioctl32,
3837 .llseek = no_llseek,
3838 .read = bttv_read,
3839 .mmap = bttv_mmap,
3840 .poll = bttv_poll,
3841 };
3842
3843 static struct video_device bttv_video_template =
3844 {
3845 .name = "UNSET",
3846 .type = VID_TYPE_CAPTURE|VID_TYPE_TUNER|
3847 VID_TYPE_CLIPPING|VID_TYPE_SCALES,
3848 .hardware = VID_HARDWARE_BT848,
3849 .fops = &bttv_fops,
3850 .minor = -1,
3851 };
3852
3853 static struct video_device bttv_vbi_template =
3854 {
3855 .name = "bt848/878 vbi",
3856 .type = VID_TYPE_TUNER|VID_TYPE_TELETEXT,
3857 .hardware = VID_HARDWARE_BT848,
3858 .fops = &bttv_fops,
3859 .minor = -1,
3860 };
3861
3862 /* ----------------------------------------------------------------------- */
3863 /* radio interface */
3864
3865 static int radio_open(struct inode *inode, struct file *file)
3866 {
3867 int minor = iminor(inode);
3868 struct bttv *btv = NULL;
3869 unsigned int i;
3870
3871 dprintk("bttv: open minor=%d\n",minor);
3872
3873 for (i = 0; i < bttv_num; i++) {
3874 if (bttvs[i].radio_dev->minor == minor) {
3875 btv = &bttvs[i];
3876 break;
3877 }
3878 }
3879 if (NULL == btv)
3880 return -ENODEV;
3881
3882 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3883 mutex_lock(&btv->lock);
3884
3885 btv->radio_user++;
3886
3887 file->private_data = btv;
3888
3889 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3890 audio_input(btv,TVAUDIO_INPUT_RADIO);
3891
3892 mutex_unlock(&btv->lock);
3893 return 0;
3894 }
3895
3896 static int radio_release(struct inode *inode, struct file *file)
3897 {
3898 struct bttv *btv = file->private_data;
3899 struct rds_command cmd;
3900
3901 btv->radio_user--;
3902
3903 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3904
3905 return 0;
3906 }
3907
3908 static int radio_do_ioctl(struct inode *inode, struct file *file,
3909 unsigned int cmd, void *arg)
3910 {
3911 struct bttv *btv = file->private_data;
3912
3913 switch (cmd) {
3914 case VIDIOCGCAP:
3915 {
3916 struct video_capability *cap = arg;
3917
3918 memset(cap,0,sizeof(*cap));
3919 strcpy(cap->name,btv->radio_dev->name);
3920 cap->type = VID_TYPE_TUNER;
3921 cap->channels = 1;
3922 cap->audios = 1;
3923 return 0;
3924 }
3925
3926 case VIDIOCGTUNER:
3927 {
3928 struct video_tuner *v = arg;
3929
3930 if(v->tuner)
3931 return -EINVAL;
3932 memset(v,0,sizeof(*v));
3933 strcpy(v->name, "Radio");
3934 bttv_call_i2c_clients(btv,cmd,v);
3935 return 0;
3936 }
3937 case VIDIOCSTUNER:
3938 /* nothing to do */
3939 return 0;
3940
3941 case BTTV_VERSION:
3942 case VIDIOCGFREQ:
3943 case VIDIOCSFREQ:
3944 case VIDIOCGAUDIO:
3945 case VIDIOCSAUDIO:
3946 case VIDIOC_LOG_STATUS:
3947 return bttv_common_ioctls(btv,cmd,arg);
3948
3949 default:
3950 return -ENOIOCTLCMD;
3951 }
3952 return 0;
3953 }
3954
3955 static int radio_ioctl(struct inode *inode, struct file *file,
3956 unsigned int cmd, unsigned long arg)
3957 {
3958 return video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
3959 }
3960
3961 static ssize_t radio_read(struct file *file, char __user *data,
3962 size_t count, loff_t *ppos)
3963 {
3964 struct bttv *btv = file->private_data;
3965 struct rds_command cmd;
3966 cmd.block_count = count/3;
3967 cmd.buffer = data;
3968 cmd.instance = file;
3969 cmd.result = -ENODEV;
3970
3971 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3972
3973 return cmd.result;
3974 }
3975
3976 static unsigned int radio_poll(struct file *file, poll_table *wait)
3977 {
3978 struct bttv *btv = file->private_data;
3979 struct rds_command cmd;
3980 cmd.instance = file;
3981 cmd.event_list = wait;
3982 cmd.result = -ENODEV;
3983 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3984
3985 return cmd.result;
3986 }
3987
3988 static const struct file_operations radio_fops =
3989 {
3990 .owner = THIS_MODULE,
3991 .open = radio_open,
3992 .read = radio_read,
3993 .release = radio_release,
3994 .ioctl = radio_ioctl,
3995 .llseek = no_llseek,
3996 .poll = radio_poll,
3997 };
3998
3999 static struct video_device radio_template =
4000 {
4001 .name = "bt848/878 radio",
4002 .type = VID_TYPE_TUNER,
4003 .hardware = VID_HARDWARE_BT848,
4004 .fops = &radio_fops,
4005 .minor = -1,
4006 };
4007
4008 /* ----------------------------------------------------------------------- */
4009 /* some debug code */
4010
4011 static int bttv_risc_decode(u32 risc)
4012 {
4013 static char *instr[16] = {
4014 [ BT848_RISC_WRITE >> 28 ] = "write",
4015 [ BT848_RISC_SKIP >> 28 ] = "skip",
4016 [ BT848_RISC_WRITEC >> 28 ] = "writec",
4017 [ BT848_RISC_JUMP >> 28 ] = "jump",
4018 [ BT848_RISC_SYNC >> 28 ] = "sync",
4019 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
4020 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
4021 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
4022 };
4023 static int incr[16] = {
4024 [ BT848_RISC_WRITE >> 28 ] = 2,
4025 [ BT848_RISC_JUMP >> 28 ] = 2,
4026 [ BT848_RISC_SYNC >> 28 ] = 2,
4027 [ BT848_RISC_WRITE123 >> 28 ] = 5,
4028 [ BT848_RISC_SKIP123 >> 28 ] = 2,
4029 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
4030 };
4031 static char *bits[] = {
4032 "be0", "be1", "be2", "be3/resync",
4033 "set0", "set1", "set2", "set3",
4034 "clr0", "clr1", "clr2", "clr3",
4035 "irq", "res", "eol", "sol",
4036 };
4037 int i;
4038
4039 printk("0x%08x [ %s", risc,
4040 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
4041 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
4042 if (risc & (1 << (i + 12)))
4043 printk(" %s",bits[i]);
4044 printk(" count=%d ]\n", risc & 0xfff);
4045 return incr[risc >> 28] ? incr[risc >> 28] : 1;
4046 }
4047
4048 static void bttv_risc_disasm(struct bttv *btv,
4049 struct btcx_riscmem *risc)
4050 {
4051 unsigned int i,j,n;
4052
4053 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
4054 btv->c.name, risc->cpu, (unsigned long)risc->dma);
4055 for (i = 0; i < (risc->size >> 2); i += n) {
4056 printk("%s: 0x%lx: ", btv->c.name,
4057 (unsigned long)(risc->dma + (i<<2)));
4058 n = bttv_risc_decode(risc->cpu[i]);
4059 for (j = 1; j < n; j++)
4060 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
4061 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
4062 risc->cpu[i+j], j);
4063 if (0 == risc->cpu[i])
4064 break;
4065 }
4066 }
4067
4068 static void bttv_print_riscaddr(struct bttv *btv)
4069 {
4070 printk(" main: %08Lx\n",
4071 (unsigned long long)btv->main.dma);
4072 printk(" vbi : o=%08Lx e=%08Lx\n",
4073 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
4074 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
4075 printk(" cap : o=%08Lx e=%08Lx\n",
4076 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
4077 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
4078 printk(" scr : o=%08Lx e=%08Lx\n",
4079 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
4080 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
4081 bttv_risc_disasm(btv, &btv->main);
4082 }
4083
4084 /* ----------------------------------------------------------------------- */
4085 /* irq handler */
4086
4087 static char *irq_name[] = {
4088 "FMTCHG", // format change detected (525 vs. 625)
4089 "VSYNC", // vertical sync (new field)
4090 "HSYNC", // horizontal sync
4091 "OFLOW", // chroma/luma AGC overflow
4092 "HLOCK", // horizontal lock changed
4093 "VPRES", // video presence changed
4094 "6", "7",
4095 "I2CDONE", // hw irc operation finished
4096 "GPINT", // gpio port triggered irq
4097 "10",
4098 "RISCI", // risc instruction triggered irq
4099 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
4100 "FTRGT", // pixel data fifo overrun
4101 "FDSR", // fifo data stream resyncronisation
4102 "PPERR", // parity error (data transfer)
4103 "RIPERR", // parity error (read risc instructions)
4104 "PABORT", // pci abort
4105 "OCERR", // risc instruction error
4106 "SCERR", // syncronisation error
4107 };
4108
4109 static void bttv_print_irqbits(u32 print, u32 mark)
4110 {
4111 unsigned int i;
4112
4113 printk("bits:");
4114 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
4115 if (print & (1 << i))
4116 printk(" %s",irq_name[i]);
4117 if (mark & (1 << i))
4118 printk("*");
4119 }
4120 }
4121
4122 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
4123 {
4124 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
4125 btv->c.nr,
4126 (unsigned long)btv->main.dma,
4127 (unsigned long)btv->main.cpu[RISC_SLOT_O_VBI+1],
4128 (unsigned long)btv->main.cpu[RISC_SLOT_O_FIELD+1],
4129 (unsigned long)rc);
4130
4131 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
4132 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
4133 "Ok, then this is harmless, don't worry ;)\n",
4134 btv->c.nr);
4135 return;
4136 }
4137 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
4138 btv->c.nr);
4139 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
4140 btv->c.nr);
4141 dump_stack();
4142 }
4143
4144 static int
4145 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
4146 {
4147 struct bttv_buffer *item;
4148
4149 memset(set,0,sizeof(*set));
4150
4151 /* capture request ? */
4152 if (!list_empty(&btv->capture)) {
4153 set->frame_irq = 1;
4154 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
4155 if (V4L2_FIELD_HAS_TOP(item->vb.field))
4156 set->top = item;
4157 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
4158 set->bottom = item;
4159
4160 /* capture request for other field ? */
4161 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
4162 (item->vb.queue.next != &btv->capture)) {
4163 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
4164 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
4165 if (NULL == set->top &&
4166 V4L2_FIELD_TOP == item->vb.field) {
4167 set->top = item;
4168 }
4169 if (NULL == set->bottom &&
4170 V4L2_FIELD_BOTTOM == item->vb.field) {
4171 set->bottom = item;
4172 }
4173 if (NULL != set->top && NULL != set->bottom)
4174 set->top_irq = 2;
4175 }
4176 }
4177 }
4178
4179 /* screen overlay ? */
4180 if (NULL != btv->screen) {
4181 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
4182 if (NULL == set->top && NULL == set->bottom) {
4183 set->top = btv->screen;
4184 set->bottom = btv->screen;
4185 }
4186 } else {
4187 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
4188 NULL == set->top) {
4189 set->top = btv->screen;
4190 }
4191 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
4192 NULL == set->bottom) {
4193 set->bottom = btv->screen;
4194 }
4195 }
4196 }
4197
4198 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
4199 btv->c.nr,set->top, set->bottom,
4200 btv->screen,set->frame_irq,set->top_irq);
4201 return 0;
4202 }
4203
4204 static void
4205 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
4206 struct bttv_buffer_set *curr, unsigned int state)
4207 {
4208 struct timeval ts;
4209
4210 do_gettimeofday(&ts);
4211
4212 if (wakeup->top == wakeup->bottom) {
4213 if (NULL != wakeup->top && curr->top != wakeup->top) {
4214 if (irq_debug > 1)
4215 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
4216 wakeup->top->vb.ts = ts;
4217 wakeup->top->vb.field_count = btv->field_count;
4218 wakeup->top->vb.state = state;
4219 wake_up(&wakeup->top->vb.done);
4220 }
4221 } else {
4222 if (NULL != wakeup->top && curr->top != wakeup->top) {
4223 if (irq_debug > 1)
4224 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
4225 wakeup->top->vb.ts = ts;
4226 wakeup->top->vb.field_count = btv->field_count;
4227 wakeup->top->vb.state = state;
4228 wake_up(&wakeup->top->vb.done);
4229 }
4230 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
4231 if (irq_debug > 1)
4232 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
4233 wakeup->bottom->vb.ts = ts;
4234 wakeup->bottom->vb.field_count = btv->field_count;
4235 wakeup->bottom->vb.state = state;
4236 wake_up(&wakeup->bottom->vb.done);
4237 }
4238 }
4239 }
4240
4241 static void
4242 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
4243 unsigned int state)
4244 {
4245 struct timeval ts;
4246
4247 if (NULL == wakeup)
4248 return;
4249
4250 do_gettimeofday(&ts);
4251 wakeup->vb.ts = ts;
4252 wakeup->vb.field_count = btv->field_count;
4253 wakeup->vb.state = state;
4254 wake_up(&wakeup->vb.done);
4255 }
4256
4257 static void bttv_irq_timeout(unsigned long data)
4258 {
4259 struct bttv *btv = (struct bttv *)data;
4260 struct bttv_buffer_set old,new;
4261 struct bttv_buffer *ovbi;
4262 struct bttv_buffer *item;
4263 unsigned long flags;
4264
4265 if (bttv_verbose) {
4266 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
4267 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
4268 btread(BT848_RISC_COUNT));
4269 bttv_print_irqbits(btread(BT848_INT_STAT),0);
4270 printk("\n");
4271 }
4272
4273 spin_lock_irqsave(&btv->s_lock,flags);
4274
4275 /* deactivate stuff */
4276 memset(&new,0,sizeof(new));
4277 old = btv->curr;
4278 ovbi = btv->cvbi;
4279 btv->curr = new;
4280 btv->cvbi = NULL;
4281 btv->loop_irq = 0;
4282 bttv_buffer_activate_video(btv, &new);
4283 bttv_buffer_activate_vbi(btv, NULL);
4284 bttv_set_dma(btv, 0);
4285
4286 /* wake up */
4287 bttv_irq_wakeup_video(btv, &old, &new, STATE_ERROR);
4288 bttv_irq_wakeup_vbi(btv, ovbi, STATE_ERROR);
4289
4290 /* cancel all outstanding capture / vbi requests */
4291 while (!list_empty(&btv->capture)) {
4292 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
4293 list_del(&item->vb.queue);
4294 item->vb.state = STATE_ERROR;
4295 wake_up(&item->vb.done);
4296 }
4297 while (!list_empty(&btv->vcapture)) {
4298 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4299 list_del(&item->vb.queue);
4300 item->vb.state = STATE_ERROR;
4301 wake_up(&item->vb.done);
4302 }
4303
4304 btv->errors++;
4305 spin_unlock_irqrestore(&btv->s_lock,flags);
4306 }
4307
4308 static void
4309 bttv_irq_wakeup_top(struct bttv *btv)
4310 {
4311 struct bttv_buffer *wakeup = btv->curr.top;
4312
4313 if (NULL == wakeup)
4314 return;
4315
4316 spin_lock(&btv->s_lock);
4317 btv->curr.top_irq = 0;
4318 btv->curr.top = NULL;
4319 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
4320
4321 do_gettimeofday(&wakeup->vb.ts);
4322 wakeup->vb.field_count = btv->field_count;
4323 wakeup->vb.state = STATE_DONE;
4324 wake_up(&wakeup->vb.done);
4325 spin_unlock(&btv->s_lock);
4326 }
4327
4328 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
4329 {
4330 if (rc < risc->dma)
4331 return 0;
4332 if (rc > risc->dma + risc->size)
4333 return 0;
4334 return 1;
4335 }
4336
4337 static void
4338 bttv_irq_switch_video(struct bttv *btv)
4339 {
4340 struct bttv_buffer_set new;
4341 struct bttv_buffer_set old;
4342 dma_addr_t rc;
4343
4344 spin_lock(&btv->s_lock);
4345
4346 /* new buffer set */
4347 bttv_irq_next_video(btv, &new);
4348 rc = btread(BT848_RISC_COUNT);
4349 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
4350 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4351 btv->framedrop++;
4352 if (debug_latency)
4353 bttv_irq_debug_low_latency(btv, rc);
4354 spin_unlock(&btv->s_lock);
4355 return;
4356 }
4357
4358 /* switch over */
4359 old = btv->curr;
4360 btv->curr = new;
4361 btv->loop_irq &= ~1;
4362 bttv_buffer_activate_video(btv, &new);
4363 bttv_set_dma(btv, 0);
4364
4365 /* switch input */
4366 if (UNSET != btv->new_input) {
4367 video_mux(btv,btv->new_input);
4368 btv->new_input = UNSET;
4369 }
4370
4371 /* wake up finished buffers */
4372 bttv_irq_wakeup_video(btv, &old, &new, STATE_DONE);
4373 spin_unlock(&btv->s_lock);
4374 }
4375
4376 static void
4377 bttv_irq_switch_vbi(struct bttv *btv)
4378 {
4379 struct bttv_buffer *new = NULL;
4380 struct bttv_buffer *old;
4381 u32 rc;
4382
4383 spin_lock(&btv->s_lock);
4384
4385 if (!list_empty(&btv->vcapture))
4386 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4387 old = btv->cvbi;
4388
4389 rc = btread(BT848_RISC_COUNT);
4390 if (NULL != old && (is_active(&old->top, rc) ||
4391 is_active(&old->bottom, rc))) {
4392 btv->framedrop++;
4393 if (debug_latency)
4394 bttv_irq_debug_low_latency(btv, rc);
4395 spin_unlock(&btv->s_lock);
4396 return;
4397 }
4398
4399 /* switch */
4400 btv->cvbi = new;
4401 btv->loop_irq &= ~4;
4402 bttv_buffer_activate_vbi(btv, new);
4403 bttv_set_dma(btv, 0);
4404
4405 bttv_irq_wakeup_vbi(btv, old, STATE_DONE);
4406 spin_unlock(&btv->s_lock);
4407 }
4408
4409 static irqreturn_t bttv_irq(int irq, void *dev_id)
4410 {
4411 u32 stat,astat;
4412 u32 dstat;
4413 int count;
4414 struct bttv *btv;
4415 int handled = 0;
4416
4417 btv=(struct bttv *)dev_id;
4418
4419 if (btv->custom_irq)
4420 handled = btv->custom_irq(btv);
4421
4422 count=0;
4423 while (1) {
4424 /* get/clear interrupt status bits */
4425 stat=btread(BT848_INT_STAT);
4426 astat=stat&btread(BT848_INT_MASK);
4427 if (!astat)
4428 break;
4429 handled = 1;
4430 btwrite(stat,BT848_INT_STAT);
4431
4432 /* get device status bits */
4433 dstat=btread(BT848_DSTATUS);
4434
4435 if (irq_debug) {
4436 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4437 "riscs=%x, riscc=%08x, ",
4438 btv->c.nr, count, btv->field_count,
4439 stat>>28, btread(BT848_RISC_COUNT));
4440 bttv_print_irqbits(stat,astat);
4441 if (stat & BT848_INT_HLOCK)
4442 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4443 ? "yes" : "no");
4444 if (stat & BT848_INT_VPRES)
4445 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4446 ? "yes" : "no");
4447 if (stat & BT848_INT_FMTCHG)
4448 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4449 ? "625" : "525");
4450 printk("\n");
4451 }
4452
4453 if (astat&BT848_INT_VSYNC)
4454 btv->field_count++;
4455
4456 if ((astat & BT848_INT_GPINT) && btv->remote) {
4457 wake_up(&btv->gpioq);
4458 bttv_input_irq(btv);
4459 }
4460
4461 if (astat & BT848_INT_I2CDONE) {
4462 btv->i2c_done = stat;
4463 wake_up(&btv->i2c_queue);
4464 }
4465
4466 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4467 bttv_irq_switch_vbi(btv);
4468
4469 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4470 bttv_irq_wakeup_top(btv);
4471
4472 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4473 bttv_irq_switch_video(btv);
4474
4475 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4476 audio_mute(btv, btv->mute); /* trigger automute */
4477
4478 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4479 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4480 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4481 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4482 btread(BT848_RISC_COUNT));
4483 bttv_print_irqbits(stat,astat);
4484 printk("\n");
4485 if (bttv_debug)
4486 bttv_print_riscaddr(btv);
4487 }
4488 if (fdsr && astat & BT848_INT_FDSR) {
4489 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4490 btv->c.nr,btread(BT848_RISC_COUNT));
4491 if (bttv_debug)
4492 bttv_print_riscaddr(btv);
4493 }
4494
4495 count++;
4496 if (count > 4) {
4497
4498 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4499 btwrite(0, BT848_INT_MASK);
4500
4501 printk(KERN_ERR
4502 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4503 } else {
4504 printk(KERN_ERR
4505 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4506
4507 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4508 BT848_INT_MASK);
4509 };
4510
4511 bttv_print_irqbits(stat,astat);
4512
4513 printk("]\n");
4514 }
4515 }
4516 btv->irq_total++;
4517 if (handled)
4518 btv->irq_me++;
4519 return IRQ_RETVAL(handled);
4520 }
4521
4522
4523 /* ----------------------------------------------------------------------- */
4524 /* initialitation */
4525
4526 static struct video_device *vdev_init(struct bttv *btv,
4527 struct video_device *template,
4528 char *type)
4529 {
4530 struct video_device *vfd;
4531
4532 vfd = video_device_alloc();
4533 if (NULL == vfd)
4534 return NULL;
4535 *vfd = *template;
4536 vfd->minor = -1;
4537 vfd->dev = &btv->c.pci->dev;
4538 vfd->release = video_device_release;
4539 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4540 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4541 type, bttv_tvcards[btv->c.type].name);
4542 return vfd;
4543 }
4544
4545 static void bttv_unregister_video(struct bttv *btv)
4546 {
4547 if (btv->video_dev) {
4548 if (-1 != btv->video_dev->minor)
4549 video_unregister_device(btv->video_dev);
4550 else
4551 video_device_release(btv->video_dev);
4552 btv->video_dev = NULL;
4553 }
4554 if (btv->vbi_dev) {
4555 if (-1 != btv->vbi_dev->minor)
4556 video_unregister_device(btv->vbi_dev);
4557 else
4558 video_device_release(btv->vbi_dev);
4559 btv->vbi_dev = NULL;
4560 }
4561 if (btv->radio_dev) {
4562 if (-1 != btv->radio_dev->minor)
4563 video_unregister_device(btv->radio_dev);
4564 else
4565 video_device_release(btv->radio_dev);
4566 btv->radio_dev = NULL;
4567 }
4568 }
4569
4570 /* register video4linux devices */
4571 static int __devinit bttv_register_video(struct bttv *btv)
4572 {
4573 if (no_overlay <= 0) {
4574 bttv_video_template.type |= VID_TYPE_OVERLAY;
4575 } else {
4576 printk("bttv: Overlay support disabled.\n");
4577 }
4578
4579 /* video */
4580 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4581 if (NULL == btv->video_dev)
4582 goto err;
4583 if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
4584 goto err;
4585 printk(KERN_INFO "bttv%d: registered device video%d\n",
4586 btv->c.nr,btv->video_dev->minor & 0x1f);
4587 if (class_device_create_file(&btv->video_dev->class_dev,
4588 &class_device_attr_card)<0) {
4589 printk(KERN_ERR "bttv%d: class_device_create_file 'card' "
4590 "failed\n", btv->c.nr);
4591 goto err;
4592 }
4593
4594 /* vbi */
4595 btv->vbi_dev = vdev_init(btv, &bttv_vbi_template, "vbi");
4596 if (NULL == btv->vbi_dev)
4597 goto err;
4598 if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
4599 goto err;
4600 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4601 btv->c.nr,btv->vbi_dev->minor & 0x1f);
4602
4603 if (!btv->has_radio)
4604 return 0;
4605 /* radio */
4606 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4607 if (NULL == btv->radio_dev)
4608 goto err;
4609 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
4610 goto err;
4611 printk(KERN_INFO "bttv%d: registered device radio%d\n",
4612 btv->c.nr,btv->radio_dev->minor & 0x1f);
4613
4614 /* all done */
4615 return 0;
4616
4617 err:
4618 bttv_unregister_video(btv);
4619 return -1;
4620 }
4621
4622
4623 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4624 /* response on cards with no firmware is not enabled by OF */
4625 static void pci_set_command(struct pci_dev *dev)
4626 {
4627 #if defined(__powerpc__)
4628 unsigned int cmd;
4629
4630 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4631 cmd = (cmd | PCI_COMMAND_MEMORY );
4632 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4633 #endif
4634 }
4635
4636 static int __devinit bttv_probe(struct pci_dev *dev,
4637 const struct pci_device_id *pci_id)
4638 {
4639 int result;
4640 unsigned char lat;
4641 struct bttv *btv;
4642
4643 if (bttv_num == BTTV_MAX)
4644 return -ENOMEM;
4645 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4646 btv=&bttvs[bttv_num];
4647 memset(btv,0,sizeof(*btv));
4648 btv->c.nr = bttv_num;
4649 sprintf(btv->c.name,"bttv%d",btv->c.nr);
4650
4651 /* initialize structs / fill in defaults */
4652 mutex_init(&btv->lock);
4653 spin_lock_init(&btv->s_lock);
4654 spin_lock_init(&btv->gpio_lock);
4655 init_waitqueue_head(&btv->gpioq);
4656 init_waitqueue_head(&btv->i2c_queue);
4657 INIT_LIST_HEAD(&btv->c.subs);
4658 INIT_LIST_HEAD(&btv->capture);
4659 INIT_LIST_HEAD(&btv->vcapture);
4660 v4l2_prio_init(&btv->prio);
4661
4662 init_timer(&btv->timeout);
4663 btv->timeout.function = bttv_irq_timeout;
4664 btv->timeout.data = (unsigned long)btv;
4665
4666 btv->i2c_rc = -1;
4667 btv->tuner_type = UNSET;
4668 btv->new_input = UNSET;
4669 btv->has_radio=radio[btv->c.nr];
4670
4671 /* pci stuff (init, get irq/mmio, ... */
4672 btv->c.pci = dev;
4673 btv->id = dev->device;
4674 if (pci_enable_device(dev)) {
4675 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4676 btv->c.nr);
4677 return -EIO;
4678 }
4679 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4680 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4681 btv->c.nr);
4682 return -EIO;
4683 }
4684 if (!request_mem_region(pci_resource_start(dev,0),
4685 pci_resource_len(dev,0),
4686 btv->c.name)) {
4687 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4688 btv->c.nr,
4689 (unsigned long long)pci_resource_start(dev,0));
4690 return -EBUSY;
4691 }
4692 pci_set_master(dev);
4693 pci_set_command(dev);
4694 pci_set_drvdata(dev,btv);
4695
4696 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4697 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4698 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4699 bttv_num,btv->id, btv->revision, pci_name(dev));
4700 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4701 btv->c.pci->irq, lat,
4702 (unsigned long long)pci_resource_start(dev,0));
4703 schedule();
4704
4705 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4706 if (NULL == btv->bt848_mmio) {
4707 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4708 result = -EIO;
4709 goto fail1;
4710 }
4711
4712 /* identify card */
4713 bttv_idcard(btv);
4714
4715 /* disable irqs, register irq handler */
4716 btwrite(0, BT848_INT_MASK);
4717 result = request_irq(btv->c.pci->irq, bttv_irq,
4718 IRQF_SHARED | IRQF_DISABLED,btv->c.name,(void *)btv);
4719 if (result < 0) {
4720 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4721 bttv_num,btv->c.pci->irq);
4722 goto fail1;
4723 }
4724
4725 if (0 != bttv_handle_chipset(btv)) {
4726 result = -EIO;
4727 goto fail2;
4728 }
4729
4730 /* init options from insmod args */
4731 btv->opt_combfilter = combfilter;
4732 btv->opt_lumafilter = lumafilter;
4733 btv->opt_automute = automute;
4734 btv->opt_chroma_agc = chroma_agc;
4735 btv->opt_adc_crush = adc_crush;
4736 btv->opt_vcr_hack = vcr_hack;
4737 btv->opt_whitecrush_upper = whitecrush_upper;
4738 btv->opt_whitecrush_lower = whitecrush_lower;
4739 btv->opt_uv_ratio = uv_ratio;
4740 btv->opt_full_luma_range = full_luma_range;
4741 btv->opt_coring = coring;
4742
4743 /* fill struct bttv with some useful defaults */
4744 btv->init.btv = btv;
4745 btv->init.ov.w.width = 320;
4746 btv->init.ov.w.height = 240;
4747 btv->init.fmt = format_by_palette(VIDEO_PALETTE_RGB24);
4748 btv->init.width = 320;
4749 btv->init.height = 240;
4750 btv->input = 0;
4751
4752 /* initialize hardware */
4753 if (bttv_gpio)
4754 bttv_gpio_tracking(btv,"pre-init");
4755
4756 bttv_risc_init_main(btv);
4757 init_bt848(btv);
4758
4759 /* gpio */
4760 btwrite(0x00, BT848_GPIO_REG_INP);
4761 btwrite(0x00, BT848_GPIO_OUT_EN);
4762 if (bttv_verbose)
4763 bttv_gpio_tracking(btv,"init");
4764
4765 /* needs to be done before i2c is registered */
4766 bttv_init_card1(btv);
4767
4768 /* register i2c + gpio */
4769 init_bttv_i2c(btv);
4770
4771 /* some card-specific stuff (needs working i2c) */
4772 bttv_init_card2(btv);
4773 init_irqreg(btv);
4774
4775 /* register video4linux + input */
4776 if (!bttv_tvcards[btv->c.type].no_video) {
4777 bttv_register_video(btv);
4778 bt848_bright(btv,32768);
4779 bt848_contrast(btv,32768);
4780 bt848_hue(btv,32768);
4781 bt848_sat(btv,32768);
4782 audio_mute(btv, 1);
4783 set_input(btv,0);
4784 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4785 btv->crop[1] = btv->crop[0]; /* current = default */
4786 disclaim_vbi_lines(btv);
4787 disclaim_video_lines(btv);
4788 }
4789
4790 /* add subdevices and autoload dvb-bt8xx if needed */
4791 if (bttv_tvcards[btv->c.type].has_dvb) {
4792 bttv_sub_add_device(&btv->c, "dvb");
4793 request_modules(btv);
4794 }
4795
4796 bttv_input_init(btv);
4797
4798 /* everything is fine */
4799 bttv_num++;
4800 return 0;
4801
4802 fail2:
4803 free_irq(btv->c.pci->irq,btv);
4804
4805 fail1:
4806 if (btv->bt848_mmio)
4807 iounmap(btv->bt848_mmio);
4808 release_mem_region(pci_resource_start(btv->c.pci,0),
4809 pci_resource_len(btv->c.pci,0));
4810 pci_set_drvdata(dev,NULL);
4811 return result;
4812 }
4813
4814 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4815 {
4816 struct bttv *btv = pci_get_drvdata(pci_dev);
4817
4818 if (bttv_verbose)
4819 printk("bttv%d: unloading\n",btv->c.nr);
4820
4821 /* shutdown everything (DMA+IRQs) */
4822 btand(~15, BT848_GPIO_DMA_CTL);
4823 btwrite(0, BT848_INT_MASK);
4824 btwrite(~0x0, BT848_INT_STAT);
4825 btwrite(0x0, BT848_GPIO_OUT_EN);
4826 if (bttv_gpio)
4827 bttv_gpio_tracking(btv,"cleanup");
4828
4829 /* tell gpio modules we are leaving ... */
4830 btv->shutdown=1;
4831 wake_up(&btv->gpioq);
4832 bttv_input_fini(btv);
4833 bttv_sub_del_devices(&btv->c);
4834
4835 /* unregister i2c_bus + input */
4836 fini_bttv_i2c(btv);
4837
4838 /* unregister video4linux */
4839 bttv_unregister_video(btv);
4840
4841 /* free allocated memory */
4842 btcx_riscmem_free(btv->c.pci,&btv->main);
4843
4844 /* free ressources */
4845 free_irq(btv->c.pci->irq,btv);
4846 iounmap(btv->bt848_mmio);
4847 release_mem_region(pci_resource_start(btv->c.pci,0),
4848 pci_resource_len(btv->c.pci,0));
4849
4850 pci_set_drvdata(pci_dev, NULL);
4851 return;
4852 }
4853
4854 #ifdef CONFIG_PM
4855 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4856 {
4857 struct bttv *btv = pci_get_drvdata(pci_dev);
4858 struct bttv_buffer_set idle;
4859 unsigned long flags;
4860
4861 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4862
4863 /* stop dma + irqs */
4864 spin_lock_irqsave(&btv->s_lock,flags);
4865 memset(&idle, 0, sizeof(idle));
4866 btv->state.video = btv->curr;
4867 btv->state.vbi = btv->cvbi;
4868 btv->state.loop_irq = btv->loop_irq;
4869 btv->curr = idle;
4870 btv->loop_irq = 0;
4871 bttv_buffer_activate_video(btv, &idle);
4872 bttv_buffer_activate_vbi(btv, NULL);
4873 bttv_set_dma(btv, 0);
4874 btwrite(0, BT848_INT_MASK);
4875 spin_unlock_irqrestore(&btv->s_lock,flags);
4876
4877 /* save bt878 state */
4878 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4879 btv->state.gpio_data = gpio_read();
4880
4881 /* save pci state */
4882 pci_save_state(pci_dev);
4883 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4884 pci_disable_device(pci_dev);
4885 btv->state.disabled = 1;
4886 }
4887 return 0;
4888 }
4889
4890 static int bttv_resume(struct pci_dev *pci_dev)
4891 {
4892 struct bttv *btv = pci_get_drvdata(pci_dev);
4893 unsigned long flags;
4894 int err;
4895
4896 dprintk("bttv%d: resume\n", btv->c.nr);
4897
4898 /* restore pci state */
4899 if (btv->state.disabled) {
4900 err=pci_enable_device(pci_dev);
4901 if (err) {
4902 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4903 btv->c.nr);
4904 return err;
4905 }
4906 btv->state.disabled = 0;
4907 }
4908 err=pci_set_power_state(pci_dev, PCI_D0);
4909 if (err) {
4910 pci_disable_device(pci_dev);
4911 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4912 btv->c.nr);
4913 btv->state.disabled = 1;
4914 return err;
4915 }
4916
4917 pci_restore_state(pci_dev);
4918
4919 /* restore bt878 state */
4920 bttv_reinit_bt848(btv);
4921 gpio_inout(0xffffff, btv->state.gpio_enable);
4922 gpio_write(btv->state.gpio_data);
4923
4924 /* restart dma */
4925 spin_lock_irqsave(&btv->s_lock,flags);
4926 btv->curr = btv->state.video;
4927 btv->cvbi = btv->state.vbi;
4928 btv->loop_irq = btv->state.loop_irq;
4929 bttv_buffer_activate_video(btv, &btv->curr);
4930 bttv_buffer_activate_vbi(btv, btv->cvbi);
4931 bttv_set_dma(btv, 0);
4932 spin_unlock_irqrestore(&btv->s_lock,flags);
4933 return 0;
4934 }
4935 #endif
4936
4937 static struct pci_device_id bttv_pci_tbl[] = {
4938 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4939 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4940 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4941 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4942 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4943 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4944 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4945 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4946 {0,}
4947 };
4948
4949 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4950
4951 static struct pci_driver bttv_pci_driver = {
4952 .name = "bttv",
4953 .id_table = bttv_pci_tbl,
4954 .probe = bttv_probe,
4955 .remove = __devexit_p(bttv_remove),
4956 #ifdef CONFIG_PM
4957 .suspend = bttv_suspend,
4958 .resume = bttv_resume,
4959 #endif
4960 };
4961
4962 static int bttv_init_module(void)
4963 {
4964 int ret;
4965
4966 bttv_num = 0;
4967
4968 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4969 (BTTV_VERSION_CODE >> 16) & 0xff,
4970 (BTTV_VERSION_CODE >> 8) & 0xff,
4971 BTTV_VERSION_CODE & 0xff);
4972 #ifdef SNAPSHOT
4973 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4974 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4975 #endif
4976 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4977 gbuffers = 2;
4978 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4979 gbufsize = BTTV_MAX_FBUF;
4980 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4981 if (bttv_verbose)
4982 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4983 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4984
4985 bttv_check_chipset();
4986
4987 ret = bus_register(&bttv_sub_bus_type);
4988 if (ret < 0) {
4989 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4990 return ret;
4991 }
4992 return pci_register_driver(&bttv_pci_driver);
4993 }
4994
4995 static void bttv_cleanup_module(void)
4996 {
4997 pci_unregister_driver(&bttv_pci_driver);
4998 bus_unregister(&bttv_sub_bus_type);
4999 return;
5000 }
5001
5002 module_init(bttv_init_module);
5003 module_exit(bttv_cleanup_module);
5004
5005 /*
5006 * Local variables:
5007 * c-basic-offset: 8
5008 * End:
5009 */
Ubuntu Artful kernel mirror