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