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