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