ccd18e4ee7892e62034a0d9b1e351107fb787749
[linux-3.10.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         v4l2_get_timestamp(&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         v4l2_get_timestamp(&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         v4l2_get_timestamp(&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  */