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