5404fcc5276dc6f39b4fdb51ffca105dfc11167f
[sfrench/cifs-2.6.git] / drivers / media / video / bt8xx / bttv-driver.c
1 /*
2
3     bttv - Bt848 frame grabber driver
4
5     Copyright (C) 1996,97,98 Ralph  Metzler <rjkm@thp.uni-koeln.de>
6                            & Marcus Metzler <mocm@thp.uni-koeln.de>
7     (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
8
9     some v4l2 code lines are taken from Justin's bttv2 driver which is
10     (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
11
12     V4L1 removal from:
13     (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
14
15     Fixes to be fully V4L2 compliant by
16     (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
17
18     Cropping and overscan support
19     Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
20     Sponsored by OPQ Systems AB
21
22     This program is free software; you can redistribute it and/or modify
23     it under the terms of the GNU General Public License as published by
24     the Free Software Foundation; either version 2 of the License, or
25     (at your option) any later version.
26
27     This program is distributed in the hope that it will be useful,
28     but WITHOUT ANY WARRANTY; without even the implied warranty of
29     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30     GNU General Public License for more details.
31
32     You should have received a copy of the GNU General Public License
33     along with this program; if not, write to the Free Software
34     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 */
36
37 #include <linux/init.h>
38 #include <linux/module.h>
39 #include <linux/delay.h>
40 #include <linux/errno.h>
41 #include <linux/fs.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/interrupt.h>
45 #include <linux/kdev_t.h>
46 #include "bttvp.h"
47 #include <media/v4l2-common.h>
48 #include <media/tvaudio.h>
49 #include <media/msp3400.h>
50
51 #include <linux/dma-mapping.h>
52
53 #include <asm/io.h>
54 #include <asm/byteorder.h>
55
56 #include <media/rds.h>
57
58
59 unsigned int bttv_num;                  /* number of Bt848s in use */
60 struct bttv bttvs[BTTV_MAX];
61
62 unsigned int bttv_debug;
63 unsigned int bttv_verbose = 1;
64 unsigned int bttv_gpio;
65
66 /* config variables */
67 #ifdef __BIG_ENDIAN
68 static unsigned int bigendian=1;
69 #else
70 static unsigned int bigendian;
71 #endif
72 static unsigned int radio[BTTV_MAX];
73 static unsigned int irq_debug;
74 static unsigned int gbuffers = 8;
75 static unsigned int gbufsize = 0x208000;
76 static unsigned int reset_crop = 1;
77
78 static int video_nr = -1;
79 static int radio_nr = -1;
80 static int vbi_nr = -1;
81 static int debug_latency;
82
83 static unsigned int fdsr;
84
85 /* options */
86 static unsigned int combfilter;
87 static unsigned int lumafilter;
88 static unsigned int automute    = 1;
89 static unsigned int chroma_agc;
90 static unsigned int adc_crush   = 1;
91 static unsigned int whitecrush_upper = 0xCF;
92 static unsigned int whitecrush_lower = 0x7F;
93 static unsigned int vcr_hack;
94 static unsigned int irq_iswitch;
95 static unsigned int uv_ratio    = 50;
96 static unsigned int full_luma_range;
97 static unsigned int coring;
98 extern int no_overlay;
99
100 /* API features (turn on/off stuff for testing) */
101 static unsigned int v4l2        = 1;
102
103 /* insmod args */
104 module_param(bttv_verbose,      int, 0644);
105 module_param(bttv_gpio,         int, 0644);
106 module_param(bttv_debug,        int, 0644);
107 module_param(irq_debug,         int, 0644);
108 module_param(debug_latency,     int, 0644);
109
110 module_param(fdsr,              int, 0444);
111 module_param(video_nr,          int, 0444);
112 module_param(radio_nr,          int, 0444);
113 module_param(vbi_nr,            int, 0444);
114 module_param(gbuffers,          int, 0444);
115 module_param(gbufsize,          int, 0444);
116 module_param(reset_crop,        int, 0444);
117
118 module_param(v4l2,              int, 0644);
119 module_param(bigendian,         int, 0644);
120 module_param(irq_iswitch,       int, 0644);
121 module_param(combfilter,        int, 0444);
122 module_param(lumafilter,        int, 0444);
123 module_param(automute,          int, 0444);
124 module_param(chroma_agc,        int, 0444);
125 module_param(adc_crush,         int, 0444);
126 module_param(whitecrush_upper,  int, 0444);
127 module_param(whitecrush_lower,  int, 0444);
128 module_param(vcr_hack,          int, 0444);
129 module_param(uv_ratio,          int, 0444);
130 module_param(full_luma_range,   int, 0444);
131 module_param(coring,            int, 0444);
132
133 module_param_array(radio, int, NULL, 0444);
134
135 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
136 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
137 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
138 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
139 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
140 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
141 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
142 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
143 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
144                  "is 1 (yes) for compatibility with older applications");
145 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
146 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
147 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
148 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
149 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
150 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
151 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
152 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
153 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
154 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
155
156 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
157 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
158 MODULE_LICENSE("GPL");
159
160 /* ----------------------------------------------------------------------- */
161 /* sysfs                                                                   */
162
163 static ssize_t show_card(struct device *cd,
164                          struct device_attribute *attr, char *buf)
165 {
166         struct video_device *vfd = container_of(cd, struct video_device, class_dev);
167         struct bttv *btv = dev_get_drvdata(vfd->dev);
168         return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
169 }
170 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
171
172 /* ----------------------------------------------------------------------- */
173 /* dvb auto-load setup                                                     */
174 #if defined(CONFIG_MODULES) && defined(MODULE)
175 static void request_module_async(struct work_struct *work)
176 {
177         request_module("dvb-bt8xx");
178 }
179
180 static void request_modules(struct bttv *dev)
181 {
182         INIT_WORK(&dev->request_module_wk, request_module_async);
183         schedule_work(&dev->request_module_wk);
184 }
185 #else
186 #define request_modules(dev)
187 #endif /* CONFIG_MODULES */
188
189
190 /* ----------------------------------------------------------------------- */
191 /* static data                                                             */
192
193 /* special timing tables from conexant... */
194 static u8 SRAM_Table[][60] =
195 {
196         /* PAL digital input over GPIO[7:0] */
197         {
198                 45, // 45 bytes following
199                 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
200                 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
201                 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
202                 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
203                 0x37,0x00,0xAF,0x21,0x00
204         },
205         /* NTSC digital input over GPIO[7:0] */
206         {
207                 51, // 51 bytes following
208                 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
209                 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
210                 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
211                 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
212                 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
213                 0x00,
214         },
215         // TGB_NTSC392 // quartzsight
216         // This table has been modified to be used for Fusion Rev D
217         {
218                 0x2A, // size of table = 42
219                 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
220                 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
221                 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
222                 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
223                 0x20, 0x00
224         }
225 };
226
227 /* minhdelayx1  first video pixel we can capture on a line and
228    hdelayx1     start of active video, both relative to rising edge of
229                 /HRESET pulse (0H) in 1 / fCLKx1.
230    swidth       width of active video and
231    totalwidth   total line width, both in 1 / fCLKx1.
232    sqwidth      total line width in square pixels.
233    vdelay       start of active video in 2 * field lines relative to
234                 trailing edge of /VRESET pulse (VDELAY register).
235    sheight      height of active video in 2 * field lines.
236    videostart0  ITU-R frame line number of the line corresponding
237                 to vdelay in the first field. */
238 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth,      \
239                 vdelay, sheight, videostart0)                            \
240         .cropcap.bounds.left = minhdelayx1,                              \
241         /* * 2 because vertically we count field lines times two, */     \
242         /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */           \
243         .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
244         /* 4 is a safety margin at the end of the line. */               \
245         .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4,        \
246         .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY,      \
247         .cropcap.defrect.left = hdelayx1,                                \
248         .cropcap.defrect.top = (videostart0) * 2,                        \
249         .cropcap.defrect.width = swidth,                                 \
250         .cropcap.defrect.height = sheight,                               \
251         .cropcap.pixelaspect.numerator = totalwidth,                     \
252         .cropcap.pixelaspect.denominator = sqwidth,
253
254 const struct bttv_tvnorm bttv_tvnorms[] = {
255         /* PAL-BDGHI */
256         /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
257         /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
258         {
259                 .v4l2_id        = V4L2_STD_PAL,
260                 .name           = "PAL",
261                 .Fsc            = 35468950,
262                 .swidth         = 924,
263                 .sheight        = 576,
264                 .totalwidth     = 1135,
265                 .adelay         = 0x7f,
266                 .bdelay         = 0x72,
267                 .iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
268                 .scaledtwidth   = 1135,
269                 .hdelayx1       = 186,
270                 .hactivex1      = 924,
271                 .vdelay         = 0x20,
272                 .vbipack        = 255, /* min (2048 / 4, 0x1ff) & 0xff */
273                 .sram           = 0,
274                 /* ITU-R frame line number of the first VBI line
275                    we can capture, of the first and second field.
276                    The last line is determined by cropcap.bounds. */
277                 .vbistart       = { 7, 320 },
278                 CROPCAP(/* minhdelayx1 */ 68,
279                         /* hdelayx1 */ 186,
280                         /* Should be (768 * 1135 + 944 / 2) / 944.
281                            cropcap.defrect is used for image width
282                            checks, so we keep the old value 924. */
283                         /* swidth */ 924,
284                         /* totalwidth */ 1135,
285                         /* sqwidth */ 944,
286                         /* vdelay */ 0x20,
287                         /* sheight */ 576,
288                         /* videostart0 */ 23)
289                 /* bt878 (and bt848?) can capture another
290                    line below active video. */
291                 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
292         },{
293                 .v4l2_id        = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
294                 .name           = "NTSC",
295                 .Fsc            = 28636363,
296                 .swidth         = 768,
297                 .sheight        = 480,
298                 .totalwidth     = 910,
299                 .adelay         = 0x68,
300                 .bdelay         = 0x5d,
301                 .iform          = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
302                 .scaledtwidth   = 910,
303                 .hdelayx1       = 128,
304                 .hactivex1      = 910,
305                 .vdelay         = 0x1a,
306                 .vbipack        = 144, /* min (1600 / 4, 0x1ff) & 0xff */
307                 .sram           = 1,
308                 .vbistart       = { 10, 273 },
309                 CROPCAP(/* minhdelayx1 */ 68,
310                         /* hdelayx1 */ 128,
311                         /* Should be (640 * 910 + 780 / 2) / 780? */
312                         /* swidth */ 768,
313                         /* totalwidth */ 910,
314                         /* sqwidth */ 780,
315                         /* vdelay */ 0x1a,
316                         /* sheight */ 480,
317                         /* videostart0 */ 23)
318         },{
319                 .v4l2_id        = V4L2_STD_SECAM,
320                 .name           = "SECAM",
321                 .Fsc            = 35468950,
322                 .swidth         = 924,
323                 .sheight        = 576,
324                 .totalwidth     = 1135,
325                 .adelay         = 0x7f,
326                 .bdelay         = 0xb0,
327                 .iform          = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
328                 .scaledtwidth   = 1135,
329                 .hdelayx1       = 186,
330                 .hactivex1      = 922,
331                 .vdelay         = 0x20,
332                 .vbipack        = 255,
333                 .sram           = 0, /* like PAL, correct? */
334                 .vbistart       = { 7, 320 },
335                 CROPCAP(/* minhdelayx1 */ 68,
336                         /* hdelayx1 */ 186,
337                         /* swidth */ 924,
338                         /* totalwidth */ 1135,
339                         /* sqwidth */ 944,
340                         /* vdelay */ 0x20,
341                         /* sheight */ 576,
342                         /* videostart0 */ 23)
343         },{
344                 .v4l2_id        = V4L2_STD_PAL_Nc,
345                 .name           = "PAL-Nc",
346                 .Fsc            = 28636363,
347                 .swidth         = 640,
348                 .sheight        = 576,
349                 .totalwidth     = 910,
350                 .adelay         = 0x68,
351                 .bdelay         = 0x5d,
352                 .iform          = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
353                 .scaledtwidth   = 780,
354                 .hdelayx1       = 130,
355                 .hactivex1      = 734,
356                 .vdelay         = 0x1a,
357                 .vbipack        = 144,
358                 .sram           = -1,
359                 .vbistart       = { 7, 320 },
360                 CROPCAP(/* minhdelayx1 */ 68,
361                         /* hdelayx1 */ 130,
362                         /* swidth */ (640 * 910 + 780 / 2) / 780,
363                         /* totalwidth */ 910,
364                         /* sqwidth */ 780,
365                         /* vdelay */ 0x1a,
366                         /* sheight */ 576,
367                         /* videostart0 */ 23)
368         },{
369                 .v4l2_id        = V4L2_STD_PAL_M,
370                 .name           = "PAL-M",
371                 .Fsc            = 28636363,
372                 .swidth         = 640,
373                 .sheight        = 480,
374                 .totalwidth     = 910,
375                 .adelay         = 0x68,
376                 .bdelay         = 0x5d,
377                 .iform          = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
378                 .scaledtwidth   = 780,
379                 .hdelayx1       = 135,
380                 .hactivex1      = 754,
381                 .vdelay         = 0x1a,
382                 .vbipack        = 144,
383                 .sram           = -1,
384                 .vbistart       = { 10, 273 },
385                 CROPCAP(/* minhdelayx1 */ 68,
386                         /* hdelayx1 */ 135,
387                         /* swidth */ (640 * 910 + 780 / 2) / 780,
388                         /* totalwidth */ 910,
389                         /* sqwidth */ 780,
390                         /* vdelay */ 0x1a,
391                         /* sheight */ 480,
392                         /* videostart0 */ 23)
393         },{
394                 .v4l2_id        = V4L2_STD_PAL_N,
395                 .name           = "PAL-N",
396                 .Fsc            = 35468950,
397                 .swidth         = 768,
398                 .sheight        = 576,
399                 .totalwidth     = 1135,
400                 .adelay         = 0x7f,
401                 .bdelay         = 0x72,
402                 .iform          = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
403                 .scaledtwidth   = 944,
404                 .hdelayx1       = 186,
405                 .hactivex1      = 922,
406                 .vdelay         = 0x20,
407                 .vbipack        = 144,
408                 .sram           = -1,
409                 .vbistart       = { 7, 320 },
410                 CROPCAP(/* minhdelayx1 */ 68,
411                         /* hdelayx1 */ 186,
412                         /* swidth */ (768 * 1135 + 944 / 2) / 944,
413                         /* totalwidth */ 1135,
414                         /* sqwidth */ 944,
415                         /* vdelay */ 0x20,
416                         /* sheight */ 576,
417                         /* videostart0 */ 23)
418         },{
419                 .v4l2_id        = V4L2_STD_NTSC_M_JP,
420                 .name           = "NTSC-JP",
421                 .Fsc            = 28636363,
422                 .swidth         = 640,
423                 .sheight        = 480,
424                 .totalwidth     = 910,
425                 .adelay         = 0x68,
426                 .bdelay         = 0x5d,
427                 .iform          = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
428                 .scaledtwidth   = 780,
429                 .hdelayx1       = 135,
430                 .hactivex1      = 754,
431                 .vdelay         = 0x16,
432                 .vbipack        = 144,
433                 .sram           = -1,
434                 .vbistart       = { 10, 273 },
435                 CROPCAP(/* minhdelayx1 */ 68,
436                         /* hdelayx1 */ 135,
437                         /* swidth */ (640 * 910 + 780 / 2) / 780,
438                         /* totalwidth */ 910,
439                         /* sqwidth */ 780,
440                         /* vdelay */ 0x16,
441                         /* sheight */ 480,
442                         /* videostart0 */ 23)
443         },{
444                 /* that one hopefully works with the strange timing
445                  * which video recorders produce when playing a NTSC
446                  * tape on a PAL TV ... */
447                 .v4l2_id        = V4L2_STD_PAL_60,
448                 .name           = "PAL-60",
449                 .Fsc            = 35468950,
450                 .swidth         = 924,
451                 .sheight        = 480,
452                 .totalwidth     = 1135,
453                 .adelay         = 0x7f,
454                 .bdelay         = 0x72,
455                 .iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
456                 .scaledtwidth   = 1135,
457                 .hdelayx1       = 186,
458                 .hactivex1      = 924,
459                 .vdelay         = 0x1a,
460                 .vbipack        = 255,
461                 .vtotal         = 524,
462                 .sram           = -1,
463                 .vbistart       = { 10, 273 },
464                 CROPCAP(/* minhdelayx1 */ 68,
465                         /* hdelayx1 */ 186,
466                         /* swidth */ 924,
467                         /* totalwidth */ 1135,
468                         /* sqwidth */ 944,
469                         /* vdelay */ 0x1a,
470                         /* sheight */ 480,
471                         /* videostart0 */ 23)
472         }
473 };
474 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
475
476 /* ----------------------------------------------------------------------- */
477 /* bttv format list
478    packed pixel formats must come first */
479 static const struct bttv_format formats[] = {
480         {
481                 .name     = "8 bpp, gray",
482                 .fourcc   = V4L2_PIX_FMT_GREY,
483                 .btformat = BT848_COLOR_FMT_Y8,
484                 .depth    = 8,
485                 .flags    = FORMAT_FLAGS_PACKED,
486         },{
487                 .name     = "8 bpp, dithered color",
488                 .fourcc   = V4L2_PIX_FMT_HI240,
489                 .btformat = BT848_COLOR_FMT_RGB8,
490                 .depth    = 8,
491                 .flags    = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
492         },{
493                 .name     = "15 bpp RGB, le",
494                 .fourcc   = V4L2_PIX_FMT_RGB555,
495                 .btformat = BT848_COLOR_FMT_RGB15,
496                 .depth    = 16,
497                 .flags    = FORMAT_FLAGS_PACKED,
498         },{
499                 .name     = "15 bpp RGB, be",
500                 .fourcc   = V4L2_PIX_FMT_RGB555X,
501                 .btformat = BT848_COLOR_FMT_RGB15,
502                 .btswap   = 0x03, /* byteswap */
503                 .depth    = 16,
504                 .flags    = FORMAT_FLAGS_PACKED,
505         },{
506                 .name     = "16 bpp RGB, le",
507                 .fourcc   = V4L2_PIX_FMT_RGB565,
508                 .btformat = BT848_COLOR_FMT_RGB16,
509                 .depth    = 16,
510                 .flags    = FORMAT_FLAGS_PACKED,
511         },{
512                 .name     = "16 bpp RGB, be",
513                 .fourcc   = V4L2_PIX_FMT_RGB565X,
514                 .btformat = BT848_COLOR_FMT_RGB16,
515                 .btswap   = 0x03, /* byteswap */
516                 .depth    = 16,
517                 .flags    = FORMAT_FLAGS_PACKED,
518         },{
519                 .name     = "24 bpp RGB, le",
520                 .fourcc   = V4L2_PIX_FMT_BGR24,
521                 .btformat = BT848_COLOR_FMT_RGB24,
522                 .depth    = 24,
523                 .flags    = FORMAT_FLAGS_PACKED,
524         },{
525                 .name     = "32 bpp RGB, le",
526                 .fourcc   = V4L2_PIX_FMT_BGR32,
527                 .btformat = BT848_COLOR_FMT_RGB32,
528                 .depth    = 32,
529                 .flags    = FORMAT_FLAGS_PACKED,
530         },{
531                 .name     = "32 bpp RGB, be",
532                 .fourcc   = V4L2_PIX_FMT_RGB32,
533                 .btformat = BT848_COLOR_FMT_RGB32,
534                 .btswap   = 0x0f, /* byte+word swap */
535                 .depth    = 32,
536                 .flags    = FORMAT_FLAGS_PACKED,
537         },{
538                 .name     = "4:2:2, packed, YUYV",
539                 .fourcc   = V4L2_PIX_FMT_YUYV,
540                 .btformat = BT848_COLOR_FMT_YUY2,
541                 .depth    = 16,
542                 .flags    = FORMAT_FLAGS_PACKED,
543         },{
544                 .name     = "4:2:2, packed, YUYV",
545                 .fourcc   = V4L2_PIX_FMT_YUYV,
546                 .btformat = BT848_COLOR_FMT_YUY2,
547                 .depth    = 16,
548                 .flags    = FORMAT_FLAGS_PACKED,
549         },{
550                 .name     = "4:2:2, packed, UYVY",
551                 .fourcc   = V4L2_PIX_FMT_UYVY,
552                 .btformat = BT848_COLOR_FMT_YUY2,
553                 .btswap   = 0x03, /* byteswap */
554                 .depth    = 16,
555                 .flags    = FORMAT_FLAGS_PACKED,
556         },{
557                 .name     = "4:2:2, planar, Y-Cb-Cr",
558                 .fourcc   = V4L2_PIX_FMT_YUV422P,
559                 .btformat = BT848_COLOR_FMT_YCrCb422,
560                 .depth    = 16,
561                 .flags    = FORMAT_FLAGS_PLANAR,
562                 .hshift   = 1,
563                 .vshift   = 0,
564         },{
565                 .name     = "4:2:0, planar, Y-Cb-Cr",
566                 .fourcc   = V4L2_PIX_FMT_YUV420,
567                 .btformat = BT848_COLOR_FMT_YCrCb422,
568                 .depth    = 12,
569                 .flags    = FORMAT_FLAGS_PLANAR,
570                 .hshift   = 1,
571                 .vshift   = 1,
572         },{
573                 .name     = "4:2:0, planar, Y-Cr-Cb",
574                 .fourcc   = V4L2_PIX_FMT_YVU420,
575                 .btformat = BT848_COLOR_FMT_YCrCb422,
576                 .depth    = 12,
577                 .flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
578                 .hshift   = 1,
579                 .vshift   = 1,
580         },{
581                 .name     = "4:1:1, planar, Y-Cb-Cr",
582                 .fourcc   = V4L2_PIX_FMT_YUV411P,
583                 .btformat = BT848_COLOR_FMT_YCrCb411,
584                 .depth    = 12,
585                 .flags    = FORMAT_FLAGS_PLANAR,
586                 .hshift   = 2,
587                 .vshift   = 0,
588         },{
589                 .name     = "4:1:0, planar, Y-Cb-Cr",
590                 .fourcc   = V4L2_PIX_FMT_YUV410,
591                 .btformat = BT848_COLOR_FMT_YCrCb411,
592                 .depth    = 9,
593                 .flags    = FORMAT_FLAGS_PLANAR,
594                 .hshift   = 2,
595                 .vshift   = 2,
596         },{
597                 .name     = "4:1:0, planar, Y-Cr-Cb",
598                 .fourcc   = V4L2_PIX_FMT_YVU410,
599                 .btformat = BT848_COLOR_FMT_YCrCb411,
600                 .depth    = 9,
601                 .flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
602                 .hshift   = 2,
603                 .vshift   = 2,
604         },{
605                 .name     = "raw scanlines",
606                 .fourcc   = -1,
607                 .btformat = BT848_COLOR_FMT_RAW,
608                 .depth    = 8,
609                 .flags    = FORMAT_FLAGS_RAW,
610         }
611 };
612 static const unsigned int FORMATS = ARRAY_SIZE(formats);
613
614 /* ----------------------------------------------------------------------- */
615
616 #define V4L2_CID_PRIVATE_CHROMA_AGC  (V4L2_CID_PRIVATE_BASE + 0)
617 #define V4L2_CID_PRIVATE_COMBFILTER  (V4L2_CID_PRIVATE_BASE + 1)
618 #define V4L2_CID_PRIVATE_AUTOMUTE    (V4L2_CID_PRIVATE_BASE + 2)
619 #define V4L2_CID_PRIVATE_LUMAFILTER  (V4L2_CID_PRIVATE_BASE + 3)
620 #define V4L2_CID_PRIVATE_AGC_CRUSH   (V4L2_CID_PRIVATE_BASE + 4)
621 #define V4L2_CID_PRIVATE_VCR_HACK    (V4L2_CID_PRIVATE_BASE + 5)
622 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER   (V4L2_CID_PRIVATE_BASE + 6)
623 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER   (V4L2_CID_PRIVATE_BASE + 7)
624 #define V4L2_CID_PRIVATE_UV_RATIO    (V4L2_CID_PRIVATE_BASE + 8)
625 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE    (V4L2_CID_PRIVATE_BASE + 9)
626 #define V4L2_CID_PRIVATE_CORING      (V4L2_CID_PRIVATE_BASE + 10)
627 #define V4L2_CID_PRIVATE_LASTP1      (V4L2_CID_PRIVATE_BASE + 11)
628
629 static const struct v4l2_queryctrl no_ctl = {
630         .name  = "42",
631         .flags = V4L2_CTRL_FLAG_DISABLED,
632 };
633 static const struct v4l2_queryctrl bttv_ctls[] = {
634         /* --- video --- */
635         {
636                 .id            = V4L2_CID_BRIGHTNESS,
637                 .name          = "Brightness",
638                 .minimum       = 0,
639                 .maximum       = 65535,
640                 .step          = 256,
641                 .default_value = 32768,
642                 .type          = V4L2_CTRL_TYPE_INTEGER,
643         },{
644                 .id            = V4L2_CID_CONTRAST,
645                 .name          = "Contrast",
646                 .minimum       = 0,
647                 .maximum       = 65535,
648                 .step          = 128,
649                 .default_value = 32768,
650                 .type          = V4L2_CTRL_TYPE_INTEGER,
651         },{
652                 .id            = V4L2_CID_SATURATION,
653                 .name          = "Saturation",
654                 .minimum       = 0,
655                 .maximum       = 65535,
656                 .step          = 128,
657                 .default_value = 32768,
658                 .type          = V4L2_CTRL_TYPE_INTEGER,
659         },{
660                 .id            = V4L2_CID_HUE,
661                 .name          = "Hue",
662                 .minimum       = 0,
663                 .maximum       = 65535,
664                 .step          = 256,
665                 .default_value = 32768,
666                 .type          = V4L2_CTRL_TYPE_INTEGER,
667         },
668         /* --- audio --- */
669         {
670                 .id            = V4L2_CID_AUDIO_MUTE,
671                 .name          = "Mute",
672                 .minimum       = 0,
673                 .maximum       = 1,
674                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
675         },{
676                 .id            = V4L2_CID_AUDIO_VOLUME,
677                 .name          = "Volume",
678                 .minimum       = 0,
679                 .maximum       = 65535,
680                 .step          = 65535/100,
681                 .default_value = 65535,
682                 .type          = V4L2_CTRL_TYPE_INTEGER,
683         },{
684                 .id            = V4L2_CID_AUDIO_BALANCE,
685                 .name          = "Balance",
686                 .minimum       = 0,
687                 .maximum       = 65535,
688                 .step          = 65535/100,
689                 .default_value = 32768,
690                 .type          = V4L2_CTRL_TYPE_INTEGER,
691         },{
692                 .id            = V4L2_CID_AUDIO_BASS,
693                 .name          = "Bass",
694                 .minimum       = 0,
695                 .maximum       = 65535,
696                 .step          = 65535/100,
697                 .default_value = 32768,
698                 .type          = V4L2_CTRL_TYPE_INTEGER,
699         },{
700                 .id            = V4L2_CID_AUDIO_TREBLE,
701                 .name          = "Treble",
702                 .minimum       = 0,
703                 .maximum       = 65535,
704                 .step          = 65535/100,
705                 .default_value = 32768,
706                 .type          = V4L2_CTRL_TYPE_INTEGER,
707         },
708         /* --- private --- */
709         {
710                 .id            = V4L2_CID_PRIVATE_CHROMA_AGC,
711                 .name          = "chroma agc",
712                 .minimum       = 0,
713                 .maximum       = 1,
714                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
715         },{
716                 .id            = V4L2_CID_PRIVATE_COMBFILTER,
717                 .name          = "combfilter",
718                 .minimum       = 0,
719                 .maximum       = 1,
720                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
721         },{
722                 .id            = V4L2_CID_PRIVATE_AUTOMUTE,
723                 .name          = "automute",
724                 .minimum       = 0,
725                 .maximum       = 1,
726                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
727         },{
728                 .id            = V4L2_CID_PRIVATE_LUMAFILTER,
729                 .name          = "luma decimation filter",
730                 .minimum       = 0,
731                 .maximum       = 1,
732                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
733         },{
734                 .id            = V4L2_CID_PRIVATE_AGC_CRUSH,
735                 .name          = "agc crush",
736                 .minimum       = 0,
737                 .maximum       = 1,
738                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
739         },{
740                 .id            = V4L2_CID_PRIVATE_VCR_HACK,
741                 .name          = "vcr hack",
742                 .minimum       = 0,
743                 .maximum       = 1,
744                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
745         },{
746                 .id            = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
747                 .name          = "whitecrush upper",
748                 .minimum       = 0,
749                 .maximum       = 255,
750                 .step          = 1,
751                 .default_value = 0xCF,
752                 .type          = V4L2_CTRL_TYPE_INTEGER,
753         },{
754                 .id            = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
755                 .name          = "whitecrush lower",
756                 .minimum       = 0,
757                 .maximum       = 255,
758                 .step          = 1,
759                 .default_value = 0x7F,
760                 .type          = V4L2_CTRL_TYPE_INTEGER,
761         },{
762                 .id            = V4L2_CID_PRIVATE_UV_RATIO,
763                 .name          = "uv ratio",
764                 .minimum       = 0,
765                 .maximum       = 100,
766                 .step          = 1,
767                 .default_value = 50,
768                 .type          = V4L2_CTRL_TYPE_INTEGER,
769         },{
770                 .id            = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
771                 .name          = "full luma range",
772                 .minimum       = 0,
773                 .maximum       = 1,
774                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
775         },{
776                 .id            = V4L2_CID_PRIVATE_CORING,
777                 .name          = "coring",
778                 .minimum       = 0,
779                 .maximum       = 3,
780                 .step          = 1,
781                 .default_value = 0,
782                 .type          = V4L2_CTRL_TYPE_INTEGER,
783         }
784
785
786
787 };
788
789 static const struct v4l2_queryctrl *ctrl_by_id(int id)
790 {
791         int i;
792
793         for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
794                 if (bttv_ctls[i].id == id)
795                         return bttv_ctls+i;
796
797         return NULL;
798 }
799
800 /* ----------------------------------------------------------------------- */
801 /* resource management                                                     */
802
803 /*
804    RESOURCE_    allocated by                freed by
805
806    VIDEO_READ   bttv_read 1)                bttv_read 2)
807
808    VIDEO_STREAM VIDIOC_STREAMON             VIDIOC_STREAMOFF
809                  VIDIOC_QBUF 1)              bttv_release
810                  VIDIOCMCAPTURE 1)
811
812    OVERLAY       VIDIOCCAPTURE on            VIDIOCCAPTURE off
813                  VIDIOC_OVERLAY on           VIDIOC_OVERLAY off
814                  3)                          bttv_release
815
816    VBI           VIDIOC_STREAMON             VIDIOC_STREAMOFF
817                  VIDIOC_QBUF 1)              bttv_release
818                  bttv_read, bttv_poll 1) 4)
819
820    1) The resource must be allocated when we enter buffer prepare functions
821       and remain allocated while buffers are in the DMA queue.
822    2) This is a single frame read.
823    3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
824       RESOURCE_OVERLAY is allocated.
825    4) This is a continuous read, implies VIDIOC_STREAMON.
826
827    Note this driver permits video input and standard changes regardless if
828    resources are allocated.
829 */
830
831 #define VBI_RESOURCES (RESOURCE_VBI)
832 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
833                          RESOURCE_VIDEO_STREAM | \
834                          RESOURCE_OVERLAY)
835
836 static
837 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
838 {
839         int xbits; /* mutual exclusive resources */
840
841         if (fh->resources & bit)
842                 /* have it already allocated */
843                 return 1;
844
845         xbits = bit;
846         if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
847                 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
848
849         /* is it free? */
850         mutex_lock(&btv->lock);
851         if (btv->resources & xbits) {
852                 /* no, someone else uses it */
853                 goto fail;
854         }
855
856         if ((bit & VIDEO_RESOURCES)
857             && 0 == (btv->resources & VIDEO_RESOURCES)) {
858                 /* Do crop - use current, don't - use default parameters. */
859                 __s32 top = btv->crop[!!fh->do_crop].rect.top;
860
861                 if (btv->vbi_end > top)
862                         goto fail;
863
864                 /* We cannot capture the same line as video and VBI data.
865                    Claim scan lines crop[].rect.top to bottom. */
866                 btv->crop_start = top;
867         } else if (bit & VBI_RESOURCES) {
868                 __s32 end = fh->vbi_fmt.end;
869
870                 if (end > btv->crop_start)
871                         goto fail;
872
873                 /* Claim scan lines above fh->vbi_fmt.end. */
874                 btv->vbi_end = end;
875         }
876
877         /* it's free, grab it */
878         fh->resources  |= bit;
879         btv->resources |= bit;
880         mutex_unlock(&btv->lock);
881         return 1;
882
883  fail:
884         mutex_unlock(&btv->lock);
885         return 0;
886 }
887
888 static
889 int check_btres(struct bttv_fh *fh, int bit)
890 {
891         return (fh->resources & bit);
892 }
893
894 static
895 int locked_btres(struct bttv *btv, int bit)
896 {
897         return (btv->resources & bit);
898 }
899
900 /* Call with btv->lock down. */
901 static void
902 disclaim_vbi_lines(struct bttv *btv)
903 {
904         btv->vbi_end = 0;
905 }
906
907 /* Call with btv->lock down. */
908 static void
909 disclaim_video_lines(struct bttv *btv)
910 {
911         const struct bttv_tvnorm *tvnorm;
912         u8 crop;
913
914         tvnorm = &bttv_tvnorms[btv->tvnorm];
915         btv->crop_start = tvnorm->cropcap.bounds.top
916                 + tvnorm->cropcap.bounds.height;
917
918         /* VBI capturing ends at VDELAY, start of video capturing, no
919            matter how many lines the VBI RISC program expects. When video
920            capturing is off, it shall no longer "preempt" VBI capturing,
921            so we set VDELAY to maximum. */
922         crop = btread(BT848_E_CROP) | 0xc0;
923         btwrite(crop, BT848_E_CROP);
924         btwrite(0xfe, BT848_E_VDELAY_LO);
925         btwrite(crop, BT848_O_CROP);
926         btwrite(0xfe, BT848_O_VDELAY_LO);
927 }
928
929 static
930 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
931 {
932         if ((fh->resources & bits) != bits) {
933                 /* trying to free ressources not allocated by us ... */
934                 printk("bttv: BUG! (btres)\n");
935         }
936         mutex_lock(&btv->lock);
937         fh->resources  &= ~bits;
938         btv->resources &= ~bits;
939
940         bits = btv->resources;
941
942         if (0 == (bits & VIDEO_RESOURCES))
943                 disclaim_video_lines(btv);
944
945         if (0 == (bits & VBI_RESOURCES))
946                 disclaim_vbi_lines(btv);
947
948         mutex_unlock(&btv->lock);
949 }
950
951 /* ----------------------------------------------------------------------- */
952 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC          */
953
954 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
955    PLL_X = Reference pre-divider (0=1, 1=2)
956    PLL_C = Post divider (0=6, 1=4)
957    PLL_I = Integer input
958    PLL_F = Fractional input
959
960    F_input = 28.636363 MHz:
961    PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
962 */
963
964 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
965 {
966         unsigned char fl, fh, fi;
967
968         /* prevent overflows */
969         fin/=4;
970         fout/=4;
971
972         fout*=12;
973         fi=fout/fin;
974
975         fout=(fout%fin)*256;
976         fh=fout/fin;
977
978         fout=(fout%fin)*256;
979         fl=fout/fin;
980
981         btwrite(fl, BT848_PLL_F_LO);
982         btwrite(fh, BT848_PLL_F_HI);
983         btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
984 }
985
986 static void set_pll(struct bttv *btv)
987 {
988         int i;
989
990         if (!btv->pll.pll_crystal)
991                 return;
992
993         if (btv->pll.pll_ofreq == btv->pll.pll_current) {
994                 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
995                 return;
996         }
997
998         if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
999                 /* no PLL needed */
1000                 if (btv->pll.pll_current == 0)
1001                         return;
1002                 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
1003                         btv->c.nr,btv->pll.pll_ifreq);
1004                 btwrite(0x00,BT848_TGCTRL);
1005                 btwrite(0x00,BT848_PLL_XCI);
1006                 btv->pll.pll_current = 0;
1007                 return;
1008         }
1009
1010         bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
1011                 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1012         set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1013
1014         for (i=0; i<10; i++) {
1015                 /*  Let other people run while the PLL stabilizes */
1016                 bttv_printk(".");
1017                 msleep(10);
1018
1019                 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1020                         btwrite(0,BT848_DSTATUS);
1021                 } else {
1022                         btwrite(0x08,BT848_TGCTRL);
1023                         btv->pll.pll_current = btv->pll.pll_ofreq;
1024                         bttv_printk(" ok\n");
1025                         return;
1026                 }
1027         }
1028         btv->pll.pll_current = -1;
1029         bttv_printk("failed\n");
1030         return;
1031 }
1032
1033 /* used to switch between the bt848's analog/digital video capture modes */
1034 static void bt848A_set_timing(struct bttv *btv)
1035 {
1036         int i, len;
1037         int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1038         int fsc       = bttv_tvnorms[btv->tvnorm].Fsc;
1039
1040         if (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
1041                 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1042                         btv->c.nr,table_idx);
1043
1044                 /* timing change...reset timing generator address */
1045                 btwrite(0x00, BT848_TGCTRL);
1046                 btwrite(0x02, BT848_TGCTRL);
1047                 btwrite(0x00, BT848_TGCTRL);
1048
1049                 len=SRAM_Table[table_idx][0];
1050                 for(i = 1; i <= len; i++)
1051                         btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1052                 btv->pll.pll_ofreq = 27000000;
1053
1054                 set_pll(btv);
1055                 btwrite(0x11, BT848_TGCTRL);
1056                 btwrite(0x41, BT848_DVSIF);
1057         } else {
1058                 btv->pll.pll_ofreq = fsc;
1059                 set_pll(btv);
1060                 btwrite(0x0, BT848_DVSIF);
1061         }
1062 }
1063
1064 /* ----------------------------------------------------------------------- */
1065
1066 static void bt848_bright(struct bttv *btv, int bright)
1067 {
1068         int value;
1069
1070         // printk("bttv: set bright: %d\n",bright); // DEBUG
1071         btv->bright = bright;
1072
1073         /* We want -128 to 127 we get 0-65535 */
1074         value = (bright >> 8) - 128;
1075         btwrite(value & 0xff, BT848_BRIGHT);
1076 }
1077
1078 static void bt848_hue(struct bttv *btv, int hue)
1079 {
1080         int value;
1081
1082         btv->hue = hue;
1083
1084         /* -128 to 127 */
1085         value = (hue >> 8) - 128;
1086         btwrite(value & 0xff, BT848_HUE);
1087 }
1088
1089 static void bt848_contrast(struct bttv *btv, int cont)
1090 {
1091         int value,hibit;
1092
1093         btv->contrast = cont;
1094
1095         /* 0-511 */
1096         value = (cont  >> 7);
1097         hibit = (value >> 6) & 4;
1098         btwrite(value & 0xff, BT848_CONTRAST_LO);
1099         btaor(hibit, ~4, BT848_E_CONTROL);
1100         btaor(hibit, ~4, BT848_O_CONTROL);
1101 }
1102
1103 static void bt848_sat(struct bttv *btv, int color)
1104 {
1105         int val_u,val_v,hibits;
1106
1107         btv->saturation = color;
1108
1109         /* 0-511 for the color */
1110         val_u   = ((color * btv->opt_uv_ratio) / 50) >> 7;
1111         val_v   = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1112         hibits  = (val_u >> 7) & 2;
1113         hibits |= (val_v >> 8) & 1;
1114         btwrite(val_u & 0xff, BT848_SAT_U_LO);
1115         btwrite(val_v & 0xff, BT848_SAT_V_LO);
1116         btaor(hibits, ~3, BT848_E_CONTROL);
1117         btaor(hibits, ~3, BT848_O_CONTROL);
1118 }
1119
1120 /* ----------------------------------------------------------------------- */
1121
1122 static int
1123 video_mux(struct bttv *btv, unsigned int input)
1124 {
1125         int mux,mask2;
1126
1127         if (input >= bttv_tvcards[btv->c.type].video_inputs)
1128                 return -EINVAL;
1129
1130         /* needed by RemoteVideo MX */
1131         mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1132         if (mask2)
1133                 gpio_inout(mask2,mask2);
1134
1135         if (input == btv->svhs)  {
1136                 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1137                 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1138         } else {
1139                 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1140                 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1141         }
1142         mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
1143         btaor(mux<<5, ~(3<<5), BT848_IFORM);
1144         dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1145                 btv->c.nr,input,mux);
1146
1147         /* card specific hook */
1148         if(bttv_tvcards[btv->c.type].muxsel_hook)
1149                 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1150         return 0;
1151 }
1152
1153 static char *audio_modes[] = {
1154         "audio: tuner", "audio: radio", "audio: extern",
1155         "audio: intern", "audio: mute"
1156 };
1157
1158 static int
1159 audio_mux(struct bttv *btv, int input, int mute)
1160 {
1161         int gpio_val, signal;
1162         struct v4l2_control ctrl;
1163         struct i2c_client *c;
1164
1165         gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1166                    bttv_tvcards[btv->c.type].gpiomask);
1167         signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1168
1169         btv->mute = mute;
1170         btv->audio = input;
1171
1172         /* automute */
1173         mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1174
1175         if (mute)
1176                 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1177         else
1178                 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1179
1180         gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1181         if (bttv_gpio)
1182                 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1183         if (in_interrupt())
1184                 return 0;
1185
1186         ctrl.id = V4L2_CID_AUDIO_MUTE;
1187         ctrl.value = btv->mute;
1188         bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, &ctrl);
1189         c = btv->i2c_msp34xx_client;
1190         if (c) {
1191                 struct v4l2_routing route;
1192
1193                 /* Note: the inputs tuner/radio/extern/intern are translated
1194                    to msp routings. This assumes common behavior for all msp3400
1195                    based TV cards. When this assumption fails, then the
1196                    specific MSP routing must be added to the card table.
1197                    For now this is sufficient. */
1198                 switch (input) {
1199                 case TVAUDIO_INPUT_RADIO:
1200                         route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1201                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1202                         break;
1203                 case TVAUDIO_INPUT_EXTERN:
1204                         route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1205                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1206                         break;
1207                 case TVAUDIO_INPUT_INTERN:
1208                         /* Yes, this is the same input as for RADIO. I doubt
1209                            if this is ever used. The only board with an INTERN
1210                            input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1211                            that was tested. My guess is that the whole INTERN
1212                            input does not work. */
1213                         route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1214                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1215                         break;
1216                 case TVAUDIO_INPUT_TUNER:
1217                 default:
1218                         /* This is the only card that uses TUNER2, and afaik,
1219                            is the only difference between the VOODOOTV_FM
1220                            and VOODOOTV_200 */
1221                         if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1222                                 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1223                                         MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1224                         else
1225                                 route.input = MSP_INPUT_DEFAULT;
1226                         break;
1227                 }
1228                 route.output = MSP_OUTPUT_DEFAULT;
1229                 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1230         }
1231         c = btv->i2c_tvaudio_client;
1232         if (c) {
1233                 struct v4l2_routing route;
1234
1235                 route.input = input;
1236                 route.output = 0;
1237                 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1238         }
1239         return 0;
1240 }
1241
1242 static inline int
1243 audio_mute(struct bttv *btv, int mute)
1244 {
1245         return audio_mux(btv, btv->audio, mute);
1246 }
1247
1248 static inline int
1249 audio_input(struct bttv *btv, int input)
1250 {
1251         return audio_mux(btv, input, btv->mute);
1252 }
1253
1254 static void
1255 bttv_crop_calc_limits(struct bttv_crop *c)
1256 {
1257         /* Scale factor min. 1:1, max. 16:1. Min. image size
1258            48 x 32. Scaled width must be a multiple of 4. */
1259
1260         if (1) {
1261                 /* For bug compatibility with VIDIOCGCAP and image
1262                    size checks in earlier driver versions. */
1263                 c->min_scaled_width = 48;
1264                 c->min_scaled_height = 32;
1265         } else {
1266                 c->min_scaled_width =
1267                         (max(48, c->rect.width >> 4) + 3) & ~3;
1268                 c->min_scaled_height =
1269                         max(32, c->rect.height >> 4);
1270         }
1271
1272         c->max_scaled_width  = c->rect.width & ~3;
1273         c->max_scaled_height = c->rect.height;
1274 }
1275
1276 static void
1277 bttv_crop_reset(struct bttv_crop *c, int norm)
1278 {
1279         c->rect = bttv_tvnorms[norm].cropcap.defrect;
1280         bttv_crop_calc_limits(c);
1281 }
1282
1283 /* Call with btv->lock down. */
1284 static int
1285 set_tvnorm(struct bttv *btv, unsigned int norm)
1286 {
1287         const struct bttv_tvnorm *tvnorm;
1288         v4l2_std_id id;
1289
1290         if (norm < 0 || norm >= BTTV_TVNORMS)
1291                 return -EINVAL;
1292
1293         tvnorm = &bttv_tvnorms[norm];
1294
1295         if (btv->tvnorm < 0 ||
1296             btv->tvnorm >= BTTV_TVNORMS ||
1297             0 != memcmp(&bttv_tvnorms[btv->tvnorm].cropcap,
1298                         &tvnorm->cropcap,
1299                         sizeof (tvnorm->cropcap))) {
1300                 bttv_crop_reset(&btv->crop[0], norm);
1301                 btv->crop[1] = btv->crop[0]; /* current = default */
1302
1303                 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1304                         btv->crop_start = tvnorm->cropcap.bounds.top
1305                                 + tvnorm->cropcap.bounds.height;
1306                 }
1307         }
1308
1309         btv->tvnorm = norm;
1310
1311         btwrite(tvnorm->adelay, BT848_ADELAY);
1312         btwrite(tvnorm->bdelay, BT848_BDELAY);
1313         btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1314               BT848_IFORM);
1315         btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1316         btwrite(1, BT848_VBI_PACK_DEL);
1317         bt848A_set_timing(btv);
1318
1319         switch (btv->c.type) {
1320         case BTTV_BOARD_VOODOOTV_FM:
1321         case BTTV_BOARD_VOODOOTV_200:
1322                 bttv_tda9880_setnorm(btv,norm);
1323                 break;
1324         }
1325         id = tvnorm->v4l2_id;
1326         bttv_call_i2c_clients(btv, VIDIOC_S_STD, &id);
1327
1328         return 0;
1329 }
1330
1331 /* Call with btv->lock down. */
1332 static void
1333 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1334 {
1335         unsigned long flags;
1336
1337         btv->input = input;
1338         if (irq_iswitch) {
1339                 spin_lock_irqsave(&btv->s_lock,flags);
1340                 if (btv->curr.frame_irq) {
1341                         /* active capture -> delayed input switch */
1342                         btv->new_input = input;
1343                 } else {
1344                         video_mux(btv,input);
1345                 }
1346                 spin_unlock_irqrestore(&btv->s_lock,flags);
1347         } else {
1348                 video_mux(btv,input);
1349         }
1350         audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1351                        TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1352         set_tvnorm(btv, norm);
1353 }
1354
1355 static void init_irqreg(struct bttv *btv)
1356 {
1357         /* clear status */
1358         btwrite(0xfffffUL, BT848_INT_STAT);
1359
1360         if (bttv_tvcards[btv->c.type].no_video) {
1361                 /* i2c only */
1362                 btwrite(BT848_INT_I2CDONE,
1363                         BT848_INT_MASK);
1364         } else {
1365                 /* full video */
1366                 btwrite((btv->triton1)  |
1367                         (btv->gpioirq ? BT848_INT_GPINT : 0) |
1368                         BT848_INT_SCERR |
1369                         (fdsr ? BT848_INT_FDSR : 0) |
1370                         BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1371                         BT848_INT_FMTCHG|BT848_INT_HLOCK|
1372                         BT848_INT_I2CDONE,
1373                         BT848_INT_MASK);
1374         }
1375 }
1376
1377 static void init_bt848(struct bttv *btv)
1378 {
1379         int val;
1380
1381         if (bttv_tvcards[btv->c.type].no_video) {
1382                 /* very basic init only */
1383                 init_irqreg(btv);
1384                 return;
1385         }
1386
1387         btwrite(0x00, BT848_CAP_CTL);
1388         btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1389         btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1390
1391         /* set planar and packed mode trigger points and         */
1392         /* set rising edge of inverted GPINTR pin as irq trigger */
1393         btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1394                 BT848_GPIO_DMA_CTL_PLTP1_16|
1395                 BT848_GPIO_DMA_CTL_PLTP23_16|
1396                 BT848_GPIO_DMA_CTL_GPINTC|
1397                 BT848_GPIO_DMA_CTL_GPINTI,
1398                 BT848_GPIO_DMA_CTL);
1399
1400         val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1401         btwrite(val, BT848_E_SCLOOP);
1402         btwrite(val, BT848_O_SCLOOP);
1403
1404         btwrite(0x20, BT848_E_VSCALE_HI);
1405         btwrite(0x20, BT848_O_VSCALE_HI);
1406         btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1407                 BT848_ADC);
1408
1409         btwrite(whitecrush_upper, BT848_WC_UP);
1410         btwrite(whitecrush_lower, BT848_WC_DOWN);
1411
1412         if (btv->opt_lumafilter) {
1413                 btwrite(0, BT848_E_CONTROL);
1414                 btwrite(0, BT848_O_CONTROL);
1415         } else {
1416                 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1417                 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1418         }
1419
1420         bt848_bright(btv,   btv->bright);
1421         bt848_hue(btv,      btv->hue);
1422         bt848_contrast(btv, btv->contrast);
1423         bt848_sat(btv,      btv->saturation);
1424
1425         /* interrupt */
1426         init_irqreg(btv);
1427 }
1428
1429 static void bttv_reinit_bt848(struct bttv *btv)
1430 {
1431         unsigned long flags;
1432
1433         if (bttv_verbose)
1434                 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1435         spin_lock_irqsave(&btv->s_lock,flags);
1436         btv->errors=0;
1437         bttv_set_dma(btv,0);
1438         spin_unlock_irqrestore(&btv->s_lock,flags);
1439
1440         init_bt848(btv);
1441         btv->pll.pll_current = -1;
1442         set_input(btv, btv->input, btv->tvnorm);
1443 }
1444
1445 static int bttv_g_ctrl(struct file *file, void *priv,
1446                                         struct v4l2_control *c)
1447 {
1448         struct bttv_fh *fh = priv;
1449         struct bttv *btv = fh->btv;
1450
1451         switch (c->id) {
1452         case V4L2_CID_BRIGHTNESS:
1453                 c->value = btv->bright;
1454                 break;
1455         case V4L2_CID_HUE:
1456                 c->value = btv->hue;
1457                 break;
1458         case V4L2_CID_CONTRAST:
1459                 c->value = btv->contrast;
1460                 break;
1461         case V4L2_CID_SATURATION:
1462                 c->value = btv->saturation;
1463                 break;
1464
1465         case V4L2_CID_AUDIO_MUTE:
1466         case V4L2_CID_AUDIO_VOLUME:
1467         case V4L2_CID_AUDIO_BALANCE:
1468         case V4L2_CID_AUDIO_BASS:
1469         case V4L2_CID_AUDIO_TREBLE:
1470                 bttv_call_i2c_clients(btv, VIDIOC_G_CTRL, c);
1471                 break;
1472
1473         case V4L2_CID_PRIVATE_CHROMA_AGC:
1474                 c->value = btv->opt_chroma_agc;
1475                 break;
1476         case V4L2_CID_PRIVATE_COMBFILTER:
1477                 c->value = btv->opt_combfilter;
1478                 break;
1479         case V4L2_CID_PRIVATE_LUMAFILTER:
1480                 c->value = btv->opt_lumafilter;
1481                 break;
1482         case V4L2_CID_PRIVATE_AUTOMUTE:
1483                 c->value = btv->opt_automute;
1484                 break;
1485         case V4L2_CID_PRIVATE_AGC_CRUSH:
1486                 c->value = btv->opt_adc_crush;
1487                 break;
1488         case V4L2_CID_PRIVATE_VCR_HACK:
1489                 c->value = btv->opt_vcr_hack;
1490                 break;
1491         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1492                 c->value = btv->opt_whitecrush_upper;
1493                 break;
1494         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1495                 c->value = btv->opt_whitecrush_lower;
1496                 break;
1497         case V4L2_CID_PRIVATE_UV_RATIO:
1498                 c->value = btv->opt_uv_ratio;
1499                 break;
1500         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1501                 c->value = btv->opt_full_luma_range;
1502                 break;
1503         case V4L2_CID_PRIVATE_CORING:
1504                 c->value = btv->opt_coring;
1505                 break;
1506         default:
1507                 return -EINVAL;
1508         }
1509         return 0;
1510 }
1511
1512 static int bttv_s_ctrl(struct file *file, void *f,
1513                                         struct v4l2_control *c)
1514 {
1515         int err;
1516         int val;
1517         struct bttv_fh *fh = f;
1518         struct bttv *btv = fh->btv;
1519
1520         err = v4l2_prio_check(&btv->prio, &fh->prio);
1521         if (0 != err)
1522                 return err;
1523
1524         switch (c->id) {
1525         case V4L2_CID_BRIGHTNESS:
1526                 bt848_bright(btv, c->value);
1527                 break;
1528         case V4L2_CID_HUE:
1529                 bt848_hue(btv, c->value);
1530                 break;
1531         case V4L2_CID_CONTRAST:
1532                 bt848_contrast(btv, c->value);
1533                 break;
1534         case V4L2_CID_SATURATION:
1535                 bt848_sat(btv, c->value);
1536                 break;
1537         case V4L2_CID_AUDIO_MUTE:
1538                 audio_mute(btv, c->value);
1539                 /* fall through */
1540         case V4L2_CID_AUDIO_VOLUME:
1541                 if (btv->volume_gpio)
1542                         btv->volume_gpio(btv, c->value);
1543
1544                 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1545                 break;
1546         case V4L2_CID_AUDIO_BALANCE:
1547         case V4L2_CID_AUDIO_BASS:
1548         case V4L2_CID_AUDIO_TREBLE:
1549                 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1550                 break;
1551
1552         case V4L2_CID_PRIVATE_CHROMA_AGC:
1553                 btv->opt_chroma_agc = c->value;
1554                 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1555                 btwrite(val, BT848_E_SCLOOP);
1556                 btwrite(val, BT848_O_SCLOOP);
1557                 break;
1558         case V4L2_CID_PRIVATE_COMBFILTER:
1559                 btv->opt_combfilter = c->value;
1560                 break;
1561         case V4L2_CID_PRIVATE_LUMAFILTER:
1562                 btv->opt_lumafilter = c->value;
1563                 if (btv->opt_lumafilter) {
1564                         btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1565                         btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1566                 } else {
1567                         btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1568                         btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1569                 }
1570                 break;
1571         case V4L2_CID_PRIVATE_AUTOMUTE:
1572                 btv->opt_automute = c->value;
1573                 break;
1574         case V4L2_CID_PRIVATE_AGC_CRUSH:
1575                 btv->opt_adc_crush = c->value;
1576                 btwrite(BT848_ADC_RESERVED |
1577                                 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1578                                 BT848_ADC);
1579                 break;
1580         case V4L2_CID_PRIVATE_VCR_HACK:
1581                 btv->opt_vcr_hack = c->value;
1582                 break;
1583         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1584                 btv->opt_whitecrush_upper = c->value;
1585                 btwrite(c->value, BT848_WC_UP);
1586                 break;
1587         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1588                 btv->opt_whitecrush_lower = c->value;
1589                 btwrite(c->value, BT848_WC_DOWN);
1590                 break;
1591         case V4L2_CID_PRIVATE_UV_RATIO:
1592                 btv->opt_uv_ratio = c->value;
1593                 bt848_sat(btv, btv->saturation);
1594                 break;
1595         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1596                 btv->opt_full_luma_range = c->value;
1597                 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1598                 break;
1599         case V4L2_CID_PRIVATE_CORING:
1600                 btv->opt_coring = c->value;
1601                 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1602                 break;
1603         default:
1604                 return -EINVAL;
1605         }
1606         return 0;
1607 }
1608
1609 /* ----------------------------------------------------------------------- */
1610
1611 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1612 {
1613         unsigned int outbits, data;
1614         outbits = btread(BT848_GPIO_OUT_EN);
1615         data    = btread(BT848_GPIO_DATA);
1616         printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1617                btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1618 }
1619
1620 static void bttv_field_count(struct bttv *btv)
1621 {
1622         int need_count = 0;
1623
1624         if (btv->users)
1625                 need_count++;
1626
1627         if (need_count) {
1628                 /* start field counter */
1629                 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1630         } else {
1631                 /* stop field counter */
1632                 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1633                 btv->field_count = 0;
1634         }
1635 }
1636
1637 static const struct bttv_format*
1638 format_by_fourcc(int fourcc)
1639 {
1640         unsigned int i;
1641
1642         for (i = 0; i < FORMATS; i++) {
1643                 if (-1 == formats[i].fourcc)
1644                         continue;
1645                 if (formats[i].fourcc == fourcc)
1646                         return formats+i;
1647         }
1648         return NULL;
1649 }
1650
1651 /* ----------------------------------------------------------------------- */
1652 /* misc helpers                                                            */
1653
1654 static int
1655 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1656                     struct bttv_buffer *new)
1657 {
1658         struct bttv_buffer *old;
1659         unsigned long flags;
1660         int retval = 0;
1661
1662         dprintk("switch_overlay: enter [new=%p]\n",new);
1663         if (new)
1664                 new->vb.state = VIDEOBUF_DONE;
1665         spin_lock_irqsave(&btv->s_lock,flags);
1666         old = btv->screen;
1667         btv->screen = new;
1668         btv->loop_irq |= 1;
1669         bttv_set_dma(btv, 0x03);
1670         spin_unlock_irqrestore(&btv->s_lock,flags);
1671         if (NULL != old) {
1672                 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1673                 bttv_dma_free(&fh->cap,btv, old);
1674                 kfree(old);
1675         }
1676         if (NULL == new)
1677                 free_btres(btv,fh,RESOURCE_OVERLAY);
1678         dprintk("switch_overlay: done\n");
1679         return retval;
1680 }
1681
1682 /* ----------------------------------------------------------------------- */
1683 /* video4linux (1) interface                                               */
1684
1685 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1686                                struct bttv_buffer *buf,
1687                                const struct bttv_format *fmt,
1688                                unsigned int width, unsigned int height,
1689                                enum v4l2_field field)
1690 {
1691         struct bttv_fh *fh = q->priv_data;
1692         int redo_dma_risc = 0;
1693         struct bttv_crop c;
1694         int norm;
1695         int rc;
1696
1697         /* check settings */
1698         if (NULL == fmt)
1699                 return -EINVAL;
1700         if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1701                 width  = RAW_BPL;
1702                 height = RAW_LINES*2;
1703                 if (width*height > buf->vb.bsize)
1704                         return -EINVAL;
1705                 buf->vb.size = buf->vb.bsize;
1706
1707                 /* Make sure tvnorm and vbi_end remain consistent
1708                    until we're done. */
1709                 mutex_lock(&btv->lock);
1710
1711                 norm = btv->tvnorm;
1712
1713                 /* In this mode capturing always starts at defrect.top
1714                    (default VDELAY), ignoring cropping parameters. */
1715                 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1716                         mutex_unlock(&btv->lock);
1717                         return -EINVAL;
1718                 }
1719
1720                 mutex_unlock(&btv->lock);
1721
1722                 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1723         } else {
1724                 mutex_lock(&btv->lock);
1725
1726                 norm = btv->tvnorm;
1727                 c = btv->crop[!!fh->do_crop];
1728
1729                 mutex_unlock(&btv->lock);
1730
1731                 if (width < c.min_scaled_width ||
1732                     width > c.max_scaled_width ||
1733                     height < c.min_scaled_height)
1734                         return -EINVAL;
1735
1736                 switch (field) {
1737                 case V4L2_FIELD_TOP:
1738                 case V4L2_FIELD_BOTTOM:
1739                 case V4L2_FIELD_ALTERNATE:
1740                         /* btv->crop counts frame lines. Max. scale
1741                            factor is 16:1 for frames, 8:1 for fields. */
1742                         if (height * 2 > c.max_scaled_height)
1743                                 return -EINVAL;
1744                         break;
1745
1746                 default:
1747                         if (height > c.max_scaled_height)
1748                                 return -EINVAL;
1749                         break;
1750                 }
1751
1752                 buf->vb.size = (width * height * fmt->depth) >> 3;
1753                 if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
1754                         return -EINVAL;
1755         }
1756
1757         /* alloc + fill struct bttv_buffer (if changed) */
1758         if (buf->vb.width != width || buf->vb.height != height ||
1759             buf->vb.field != field ||
1760             buf->tvnorm != norm || buf->fmt != fmt ||
1761             buf->crop.top != c.rect.top ||
1762             buf->crop.left != c.rect.left ||
1763             buf->crop.width != c.rect.width ||
1764             buf->crop.height != c.rect.height) {
1765                 buf->vb.width  = width;
1766                 buf->vb.height = height;
1767                 buf->vb.field  = field;
1768                 buf->tvnorm    = norm;
1769                 buf->fmt       = fmt;
1770                 buf->crop      = c.rect;
1771                 redo_dma_risc = 1;
1772         }
1773
1774         /* alloc risc memory */
1775         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1776                 redo_dma_risc = 1;
1777                 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1778                         goto fail;
1779         }
1780
1781         if (redo_dma_risc)
1782                 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1783                         goto fail;
1784
1785         buf->vb.state = VIDEOBUF_PREPARED;
1786         return 0;
1787
1788  fail:
1789         bttv_dma_free(q,btv,buf);
1790         return rc;
1791 }
1792
1793 static int
1794 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1795 {
1796         struct bttv_fh *fh = q->priv_data;
1797
1798         *size = fh->fmt->depth*fh->width*fh->height >> 3;
1799         if (0 == *count)
1800                 *count = gbuffers;
1801         while (*size * *count > gbuffers * gbufsize)
1802                 (*count)--;
1803         return 0;
1804 }
1805
1806 static int
1807 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1808                enum v4l2_field field)
1809 {
1810         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1811         struct bttv_fh *fh = q->priv_data;
1812
1813         return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1814                                    fh->width, fh->height, field);
1815 }
1816
1817 static void
1818 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1819 {
1820         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1821         struct bttv_fh *fh = q->priv_data;
1822         struct bttv    *btv = fh->btv;
1823
1824         buf->vb.state = VIDEOBUF_QUEUED;
1825         list_add_tail(&buf->vb.queue,&btv->capture);
1826         if (!btv->curr.frame_irq) {
1827                 btv->loop_irq |= 1;
1828                 bttv_set_dma(btv, 0x03);
1829         }
1830 }
1831
1832 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1833 {
1834         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1835         struct bttv_fh *fh = q->priv_data;
1836
1837         bttv_dma_free(q,fh->btv,buf);
1838 }
1839
1840 static struct videobuf_queue_ops bttv_video_qops = {
1841         .buf_setup    = buffer_setup,
1842         .buf_prepare  = buffer_prepare,
1843         .buf_queue    = buffer_queue,
1844         .buf_release  = buffer_release,
1845 };
1846
1847 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1848 {
1849         struct bttv_fh *fh  = priv;
1850         struct bttv *btv = fh->btv;
1851         unsigned int i;
1852         int err;
1853
1854         err = v4l2_prio_check(&btv->prio, &fh->prio);
1855         if (0 != err)
1856                 return err;
1857
1858         for (i = 0; i < BTTV_TVNORMS; i++)
1859                 if (*id & bttv_tvnorms[i].v4l2_id)
1860                         break;
1861         if (i == BTTV_TVNORMS)
1862                 return -EINVAL;
1863
1864         mutex_lock(&btv->lock);
1865         set_tvnorm(btv, i);
1866         mutex_unlock(&btv->lock);
1867
1868         return 0;
1869 }
1870
1871 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1872 {
1873         struct bttv_fh *fh = f;
1874         struct bttv *btv = fh->btv;
1875
1876         if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1877                 *id = V4L2_STD_625_50;
1878         else
1879                 *id = V4L2_STD_525_60;
1880         return 0;
1881 }
1882
1883 static int bttv_enum_input(struct file *file, void *priv,
1884                                         struct v4l2_input *i)
1885 {
1886         struct bttv_fh *fh = priv;
1887         struct bttv *btv = fh->btv;
1888         unsigned int n;
1889
1890         n = i->index;
1891
1892         if (n >= bttv_tvcards[btv->c.type].video_inputs)
1893                 return -EINVAL;
1894
1895         memset(i, 0, sizeof(*i));
1896
1897         i->index    = n;
1898         i->type     = V4L2_INPUT_TYPE_CAMERA;
1899         i->audioset = 1;
1900
1901         if (i->index == bttv_tvcards[btv->c.type].tuner) {
1902                 sprintf(i->name, "Television");
1903                 i->type  = V4L2_INPUT_TYPE_TUNER;
1904                 i->tuner = 0;
1905         } else if (i->index == btv->svhs) {
1906                 sprintf(i->name, "S-Video");
1907         } else {
1908                 sprintf(i->name, "Composite%d", i->index);
1909         }
1910
1911         if (i->index == btv->input) {
1912                 __u32 dstatus = btread(BT848_DSTATUS);
1913                 if (0 == (dstatus & BT848_DSTATUS_PRES))
1914                         i->status |= V4L2_IN_ST_NO_SIGNAL;
1915                 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1916                         i->status |= V4L2_IN_ST_NO_H_LOCK;
1917         }
1918
1919         for (n = 0; n < BTTV_TVNORMS; n++)
1920                 i->std |= bttv_tvnorms[n].v4l2_id;
1921
1922         return 0;
1923 }
1924
1925 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1926 {
1927         struct bttv_fh *fh = priv;
1928         struct bttv *btv = fh->btv;
1929
1930         *i = btv->input;
1931         return 0;
1932 }
1933
1934 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1935 {
1936         struct bttv_fh *fh  = priv;
1937         struct bttv *btv = fh->btv;
1938
1939         int err;
1940
1941         err = v4l2_prio_check(&btv->prio, &fh->prio);
1942         if (0 != err)
1943                 return err;
1944
1945         if (i > bttv_tvcards[btv->c.type].video_inputs)
1946                 return -EINVAL;
1947
1948         mutex_lock(&btv->lock);
1949         set_input(btv, i, btv->tvnorm);
1950         mutex_unlock(&btv->lock);
1951         return 0;
1952 }
1953
1954 static int bttv_s_tuner(struct file *file, void *priv,
1955                                         struct v4l2_tuner *t)
1956 {
1957         struct bttv_fh *fh  = priv;
1958         struct bttv *btv = fh->btv;
1959         int err;
1960
1961         err = v4l2_prio_check(&btv->prio, &fh->prio);
1962         if (0 != err)
1963                 return err;
1964
1965         if (UNSET == bttv_tvcards[btv->c.type].tuner)
1966                 return -EINVAL;
1967
1968         if (0 != t->index)
1969                 return -EINVAL;
1970
1971         mutex_lock(&btv->lock);
1972         bttv_call_i2c_clients(btv, VIDIOC_S_TUNER, t);
1973
1974         if (btv->audio_mode_gpio)
1975                 btv->audio_mode_gpio(btv, t, 1);
1976
1977         mutex_unlock(&btv->lock);
1978
1979         return 0;
1980 }
1981
1982 static int bttv_g_frequency(struct file *file, void *priv,
1983                                         struct v4l2_frequency *f)
1984 {
1985         struct bttv_fh *fh  = priv;
1986         struct bttv *btv = fh->btv;
1987         int err;
1988
1989         err = v4l2_prio_check(&btv->prio, &fh->prio);
1990         if (0 != err)
1991                 return err;
1992
1993         f->type = V4L2_TUNER_ANALOG_TV;
1994         f->frequency = btv->freq;
1995
1996         return 0;
1997 }
1998
1999 static int bttv_s_frequency(struct file *file, void *priv,
2000                                         struct v4l2_frequency *f)
2001 {
2002         struct bttv_fh *fh  = priv;
2003         struct bttv *btv = fh->btv;
2004         int err;
2005
2006         err = v4l2_prio_check(&btv->prio, &fh->prio);
2007         if (0 != err)
2008                 return err;
2009
2010         if (unlikely(f->tuner != 0))
2011                 return -EINVAL;
2012         if (unlikely(f->type != V4L2_TUNER_ANALOG_TV))
2013                 return -EINVAL;
2014         mutex_lock(&btv->lock);
2015         btv->freq = f->frequency;
2016         bttv_call_i2c_clients(btv, VIDIOC_S_FREQUENCY, f);
2017         if (btv->has_matchbox && btv->radio_user)
2018                 tea5757_set_freq(btv, btv->freq);
2019         mutex_unlock(&btv->lock);
2020         return 0;
2021 }
2022
2023 static int bttv_log_status(struct file *file, void *f)
2024 {
2025         struct bttv_fh *fh  = f;
2026         struct bttv *btv = fh->btv;
2027
2028         printk(KERN_INFO "bttv%d: ========  START STATUS CARD #%d  ========\n",
2029                         btv->c.nr, btv->c.nr);
2030         bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
2031         printk(KERN_INFO "bttv%d: ========  END STATUS CARD   #%d  ========\n",
2032                         btv->c.nr, btv->c.nr);
2033         return 0;
2034 }
2035
2036 #ifdef CONFIG_VIDEO_ADV_DEBUG
2037 static int bttv_g_register(struct file *file, void *f,
2038                                         struct v4l2_register *reg)
2039 {
2040         struct bttv_fh *fh = f;
2041         struct bttv *btv = fh->btv;
2042
2043         if (!capable(CAP_SYS_ADMIN))
2044                 return -EPERM;
2045
2046         if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
2047                 return -EINVAL;
2048
2049         /* bt848 has a 12-bit register space */
2050         reg->reg &= 0xfff;
2051         reg->val = btread(reg->reg);
2052
2053         return 0;
2054 }
2055
2056 static int bttv_s_register(struct file *file, void *f,
2057                                         struct v4l2_register *reg)
2058 {
2059         struct bttv_fh *fh = f;
2060         struct bttv *btv = fh->btv;
2061
2062         if (!capable(CAP_SYS_ADMIN))
2063                 return -EPERM;
2064
2065         if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
2066                 return -EINVAL;
2067
2068         /* bt848 has a 12-bit register space */
2069         reg->reg &= 0xfff;
2070         btwrite(reg->val, reg->reg);
2071
2072         return 0;
2073 }
2074 #endif
2075
2076 /* Given cropping boundaries b and the scaled width and height of a
2077    single field or frame, which must not exceed hardware limits, this
2078    function adjusts the cropping parameters c. */
2079 static void
2080 bttv_crop_adjust        (struct bttv_crop *             c,
2081                          const struct v4l2_rect *       b,
2082                          __s32                          width,
2083                          __s32                          height,
2084                          enum v4l2_field                field)
2085 {
2086         __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2087         __s32 max_left;
2088         __s32 max_top;
2089
2090         if (width < c->min_scaled_width) {
2091                 /* Max. hor. scale factor 16:1. */
2092                 c->rect.width = width * 16;
2093         } else if (width > c->max_scaled_width) {
2094                 /* Min. hor. scale factor 1:1. */
2095                 c->rect.width = width;
2096
2097                 max_left = b->left + b->width - width;
2098                 max_left = min(max_left, (__s32) MAX_HDELAY);
2099                 if (c->rect.left > max_left)
2100                         c->rect.left = max_left;
2101         }
2102
2103         if (height < c->min_scaled_height) {
2104                 /* Max. vert. scale factor 16:1, single fields 8:1. */
2105                 c->rect.height = height * 16;
2106         } else if (frame_height > c->max_scaled_height) {
2107                 /* Min. vert. scale factor 1:1.
2108                    Top and height count field lines times two. */
2109                 c->rect.height = (frame_height + 1) & ~1;
2110
2111                 max_top = b->top + b->height - c->rect.height;
2112                 if (c->rect.top > max_top)
2113                         c->rect.top = max_top;
2114         }
2115
2116         bttv_crop_calc_limits(c);
2117 }
2118
2119 /* Returns an error if scaling to a frame or single field with the given
2120    width and height is not possible with the current cropping parameters
2121    and width aligned according to width_mask. If adjust_size is TRUE the
2122    function may adjust the width and/or height instead, rounding width
2123    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2124    also adjust the current cropping parameters to get closer to the
2125    desired image size. */
2126 static int
2127 limit_scaled_size       (struct bttv_fh *               fh,
2128                          __s32 *                        width,
2129                          __s32 *                        height,
2130                          enum v4l2_field                field,
2131                          unsigned int                   width_mask,
2132                          unsigned int                   width_bias,
2133                          int                            adjust_size,
2134                          int                            adjust_crop)
2135 {
2136         struct bttv *btv = fh->btv;
2137         const struct v4l2_rect *b;
2138         struct bttv_crop *c;
2139         __s32 min_width;
2140         __s32 min_height;
2141         __s32 max_width;
2142         __s32 max_height;
2143         int rc;
2144
2145         BUG_ON((int) width_mask >= 0 ||
2146                width_bias >= (unsigned int) -width_mask);
2147
2148         /* Make sure tvnorm, vbi_end and the current cropping parameters
2149            remain consistent until we're done. */
2150         mutex_lock(&btv->lock);
2151
2152         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2153
2154         /* Do crop - use current, don't - use default parameters. */
2155         c = &btv->crop[!!fh->do_crop];
2156
2157         if (fh->do_crop
2158             && adjust_size
2159             && adjust_crop
2160             && !locked_btres(btv, VIDEO_RESOURCES)) {
2161                 min_width = 48;
2162                 min_height = 32;
2163
2164                 /* We cannot scale up. When the scaled image is larger
2165                    than crop.rect we adjust the crop.rect as required
2166                    by the V4L2 spec, hence cropcap.bounds are our limit. */
2167                 max_width = min(b->width, (__s32) MAX_HACTIVE);
2168                 max_height = b->height;
2169
2170                 /* We cannot capture the same line as video and VBI data.
2171                    Note btv->vbi_end is really a minimum, see
2172                    bttv_vbi_try_fmt(). */
2173                 if (btv->vbi_end > b->top) {
2174                         max_height -= btv->vbi_end - b->top;
2175                         rc = -EBUSY;
2176                         if (min_height > max_height)
2177                                 goto fail;
2178                 }
2179         } else {
2180                 rc = -EBUSY;
2181                 if (btv->vbi_end > c->rect.top)
2182                         goto fail;
2183
2184                 min_width  = c->min_scaled_width;
2185                 min_height = c->min_scaled_height;
2186                 max_width  = c->max_scaled_width;
2187                 max_height = c->max_scaled_height;
2188
2189                 adjust_crop = 0;
2190         }
2191
2192         min_width = (min_width - width_mask - 1) & width_mask;
2193         max_width = max_width & width_mask;
2194
2195         /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2196         min_height = min_height;
2197         /* Min. scale factor is 1:1. */
2198         max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2199
2200         if (adjust_size) {
2201                 *width = clamp(*width, min_width, max_width);
2202                 *height = clamp(*height, min_height, max_height);
2203
2204                 /* Round after clamping to avoid overflow. */
2205                 *width = (*width + width_bias) & width_mask;
2206
2207                 if (adjust_crop) {
2208                         bttv_crop_adjust(c, b, *width, *height, field);
2209
2210                         if (btv->vbi_end > c->rect.top) {
2211                                 /* Move the crop window out of the way. */
2212                                 c->rect.top = btv->vbi_end;
2213                         }
2214                 }
2215         } else {
2216                 rc = -EINVAL;
2217                 if (*width  < min_width ||
2218                     *height < min_height ||
2219                     *width  > max_width ||
2220                     *height > max_height ||
2221                     0 != (*width & ~width_mask))
2222                         goto fail;
2223         }
2224
2225         rc = 0; /* success */
2226
2227  fail:
2228         mutex_unlock(&btv->lock);
2229
2230         return rc;
2231 }
2232
2233 /* Returns an error if the given overlay window dimensions are not
2234    possible with the current cropping parameters. If adjust_size is
2235    TRUE the function may adjust the window width and/or height
2236    instead, however it always rounds the horizontal position and
2237    width as btcx_align() does. If adjust_crop is TRUE the function
2238    may also adjust the current cropping parameters to get closer
2239    to the desired window size. */
2240 static int
2241 verify_window           (struct bttv_fh *               fh,
2242                          struct v4l2_window *           win,
2243                          int                            adjust_size,
2244                          int                            adjust_crop)
2245 {
2246         enum v4l2_field field;
2247         unsigned int width_mask;
2248         int rc;
2249
2250         if (win->w.width  < 48 || win->w.height < 32)
2251                 return -EINVAL;
2252         if (win->clipcount > 2048)
2253                 return -EINVAL;
2254
2255         field = win->field;
2256
2257         if (V4L2_FIELD_ANY == field) {
2258                 __s32 height2;
2259
2260                 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2261                 field = (win->w.height > height2)
2262                         ? V4L2_FIELD_INTERLACED
2263                         : V4L2_FIELD_TOP;
2264         }
2265         switch (field) {
2266         case V4L2_FIELD_TOP:
2267         case V4L2_FIELD_BOTTOM:
2268         case V4L2_FIELD_INTERLACED:
2269                 break;
2270         default:
2271                 return -EINVAL;
2272         }
2273
2274         /* 4-byte alignment. */
2275         if (NULL == fh->ovfmt)
2276                 return -EINVAL;
2277         width_mask = ~0;
2278         switch (fh->ovfmt->depth) {
2279         case 8:
2280         case 24:
2281                 width_mask = ~3;
2282                 break;
2283         case 16:
2284                 width_mask = ~1;
2285                 break;
2286         case 32:
2287                 break;
2288         default:
2289                 BUG();
2290         }
2291
2292         win->w.width -= win->w.left & ~width_mask;
2293         win->w.left = (win->w.left - width_mask - 1) & width_mask;
2294
2295         rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2296                                field, width_mask,
2297                                /* width_bias: round down */ 0,
2298                                adjust_size, adjust_crop);
2299         if (0 != rc)
2300                 return rc;
2301
2302         win->field = field;
2303         return 0;
2304 }
2305
2306 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2307                         struct v4l2_window *win, int fixup)
2308 {
2309         struct v4l2_clip *clips = NULL;
2310         int n,size,retval = 0;
2311
2312         if (NULL == fh->ovfmt)
2313                 return -EINVAL;
2314         if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2315                 return -EINVAL;
2316         retval = verify_window(fh, win,
2317                                /* adjust_size */ fixup,
2318                                /* adjust_crop */ fixup);
2319         if (0 != retval)
2320                 return retval;
2321
2322         /* copy clips  --  luckily v4l1 + v4l2 are binary
2323            compatible here ...*/
2324         n = win->clipcount;
2325         size = sizeof(*clips)*(n+4);
2326         clips = kmalloc(size,GFP_KERNEL);
2327         if (NULL == clips)
2328                 return -ENOMEM;
2329         if (n > 0) {
2330                 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2331                         kfree(clips);
2332                         return -EFAULT;
2333                 }
2334         }
2335         /* clip against screen */
2336         if (NULL != btv->fbuf.base)
2337                 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2338                                       &win->w, clips, n);
2339         btcx_sort_clips(clips,n);
2340
2341         /* 4-byte alignments */
2342         switch (fh->ovfmt->depth) {
2343         case 8:
2344         case 24:
2345                 btcx_align(&win->w, clips, n, 3);
2346                 break;
2347         case 16:
2348                 btcx_align(&win->w, clips, n, 1);
2349                 break;
2350         case 32:
2351                 /* no alignment fixups needed */
2352                 break;
2353         default:
2354                 BUG();
2355         }
2356
2357         mutex_lock(&fh->cap.vb_lock);
2358         kfree(fh->ov.clips);
2359         fh->ov.clips    = clips;
2360         fh->ov.nclips   = n;
2361
2362         fh->ov.w        = win->w;
2363         fh->ov.field    = win->field;
2364         fh->ov.setup_ok = 1;
2365         btv->init.ov.w.width   = win->w.width;
2366         btv->init.ov.w.height  = win->w.height;
2367         btv->init.ov.field     = win->field;
2368
2369         /* update overlay if needed */
2370         retval = 0;
2371         if (check_btres(fh, RESOURCE_OVERLAY)) {
2372                 struct bttv_buffer *new;
2373
2374                 new = videobuf_pci_alloc(sizeof(*new));
2375                 new->crop = btv->crop[!!fh->do_crop].rect;
2376                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2377                 retval = bttv_switch_overlay(btv,fh,new);
2378         }
2379         mutex_unlock(&fh->cap.vb_lock);
2380         return retval;
2381 }
2382
2383 /* ----------------------------------------------------------------------- */
2384
2385 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2386 {
2387         struct videobuf_queue* q = NULL;
2388
2389         switch (fh->type) {
2390         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2391                 q = &fh->cap;
2392                 break;
2393         case V4L2_BUF_TYPE_VBI_CAPTURE:
2394                 q = &fh->vbi;
2395                 break;
2396         default:
2397                 BUG();
2398         }
2399         return q;
2400 }
2401
2402 static int bttv_resource(struct bttv_fh *fh)
2403 {
2404         int res = 0;
2405
2406         switch (fh->type) {
2407         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2408                 res = RESOURCE_VIDEO_STREAM;
2409                 break;
2410         case V4L2_BUF_TYPE_VBI_CAPTURE:
2411                 res = RESOURCE_VBI;
2412                 break;
2413         default:
2414                 BUG();
2415         }
2416         return res;
2417 }
2418
2419 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2420 {
2421         struct videobuf_queue *q = bttv_queue(fh);
2422         int res = bttv_resource(fh);
2423
2424         if (check_btres(fh,res))
2425                 return -EBUSY;
2426         if (videobuf_queue_is_busy(q))
2427                 return -EBUSY;
2428         fh->type = type;
2429         return 0;
2430 }
2431
2432 static void
2433 pix_format_set_size     (struct v4l2_pix_format *       f,
2434                          const struct bttv_format *     fmt,
2435                          unsigned int                   width,
2436                          unsigned int                   height)
2437 {
2438         f->width = width;
2439         f->height = height;
2440
2441         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2442                 f->bytesperline = width; /* Y plane */
2443                 f->sizeimage = (width * height * fmt->depth) >> 3;
2444         } else {
2445                 f->bytesperline = (width * fmt->depth) >> 3;
2446                 f->sizeimage = height * f->bytesperline;
2447         }
2448 }
2449
2450 static int bttv_g_fmt_cap(struct file *file, void *priv,
2451                                         struct v4l2_format *f)
2452 {
2453         struct bttv_fh *fh  = priv;
2454
2455         pix_format_set_size(&f->fmt.pix, fh->fmt,
2456                                 fh->width, fh->height);
2457         f->fmt.pix.field        = fh->cap.field;
2458         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
2459
2460         return 0;
2461 }
2462
2463 static int bttv_g_fmt_overlay(struct file *file, void *priv,
2464                                         struct v4l2_format *f)
2465 {
2466         struct bttv_fh *fh  = priv;
2467
2468         f->fmt.win.w     = fh->ov.w;
2469         f->fmt.win.field = fh->ov.field;
2470
2471         return 0;
2472 }
2473
2474 static int bttv_try_fmt_cap(struct file *file, void *priv,
2475                                                 struct v4l2_format *f)
2476 {
2477         const struct bttv_format *fmt;
2478         struct bttv_fh *fh = priv;
2479         struct bttv *btv = fh->btv;
2480         enum v4l2_field field;
2481         __s32 width, height;
2482         int rc;
2483
2484         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2485         if (NULL == fmt)
2486                 return -EINVAL;
2487
2488         field = f->fmt.pix.field;
2489
2490         if (V4L2_FIELD_ANY == field) {
2491                 __s32 height2;
2492
2493                 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2494                 field = (f->fmt.pix.height > height2)
2495                         ? V4L2_FIELD_INTERLACED
2496                         : V4L2_FIELD_BOTTOM;
2497         }
2498
2499         if (V4L2_FIELD_SEQ_BT == field)
2500                 field = V4L2_FIELD_SEQ_TB;
2501
2502         switch (field) {
2503         case V4L2_FIELD_TOP:
2504         case V4L2_FIELD_BOTTOM:
2505         case V4L2_FIELD_ALTERNATE:
2506         case V4L2_FIELD_INTERLACED:
2507                 break;
2508         case V4L2_FIELD_SEQ_TB:
2509                 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2510                         return -EINVAL;
2511                 break;
2512         default:
2513                 return -EINVAL;
2514         }
2515
2516         width = f->fmt.pix.width;
2517         height = f->fmt.pix.height;
2518
2519         rc = limit_scaled_size(fh, &width, &height, field,
2520                                /* width_mask: 4 pixels */ ~3,
2521                                /* width_bias: nearest */ 2,
2522                                /* adjust_size */ 1,
2523                                /* adjust_crop */ 0);
2524         if (0 != rc)
2525                 return rc;
2526
2527         /* update data for the application */
2528         f->fmt.pix.field = field;
2529         pix_format_set_size(&f->fmt.pix, fmt, width, height);
2530
2531         return 0;
2532 }
2533
2534 static int bttv_try_fmt_overlay(struct file *file, void *priv,
2535                                                 struct v4l2_format *f)
2536 {
2537         struct bttv_fh *fh = priv;
2538
2539         return verify_window(fh, &f->fmt.win,
2540                         /* adjust_size */ 1,
2541                         /* adjust_crop */ 0);
2542 }
2543
2544 static int bttv_s_fmt_cap(struct file *file, void *priv,
2545                                 struct v4l2_format *f)
2546 {
2547         int retval;
2548         const struct bttv_format *fmt;
2549         struct bttv_fh *fh = priv;
2550         struct bttv *btv = fh->btv;
2551         __s32 width, height;
2552         enum v4l2_field field;
2553
2554         retval = bttv_switch_type(fh, f->type);
2555         if (0 != retval)
2556                 return retval;
2557
2558         retval = bttv_try_fmt_cap(file, priv, f);
2559         if (0 != retval)
2560                 return retval;
2561
2562         width = f->fmt.pix.width;
2563         height = f->fmt.pix.height;
2564         field = f->fmt.pix.field;
2565
2566         retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2567                                /* width_mask: 4 pixels */ ~3,
2568                                /* width_bias: nearest */ 2,
2569                                /* adjust_size */ 1,
2570                                /* adjust_crop */ 1);
2571         if (0 != retval)
2572                 return retval;
2573
2574         f->fmt.pix.field = field;
2575
2576         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2577
2578         /* update our state informations */
2579         mutex_lock(&fh->cap.vb_lock);
2580         fh->fmt              = fmt;
2581         fh->cap.field        = f->fmt.pix.field;
2582         fh->cap.last         = V4L2_FIELD_NONE;
2583         fh->width            = f->fmt.pix.width;
2584         fh->height           = f->fmt.pix.height;
2585         btv->init.fmt        = fmt;
2586         btv->init.width      = f->fmt.pix.width;
2587         btv->init.height     = f->fmt.pix.height;
2588         mutex_unlock(&fh->cap.vb_lock);
2589
2590         return 0;
2591 }
2592
2593 static int bttv_s_fmt_overlay(struct file *file, void *priv,
2594                                 struct v4l2_format *f)
2595 {
2596         struct bttv_fh *fh = priv;
2597         struct bttv *btv = fh->btv;
2598
2599         if (no_overlay > 0) {
2600                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2601                 return -EINVAL;
2602         }
2603
2604         return setup_window(fh, btv, &f->fmt.win, 1);
2605 }
2606
2607 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2608 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2609 {
2610         int retval;
2611         unsigned int i;
2612         struct bttv_fh *fh = priv;
2613
2614         mutex_lock(&fh->cap.vb_lock);
2615         retval = videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2616                                      V4L2_MEMORY_MMAP);
2617         if (retval < 0) {
2618                 mutex_unlock(&fh->cap.vb_lock);
2619                 return retval;
2620         }
2621
2622         gbuffers = retval;
2623         memset(mbuf, 0, sizeof(*mbuf));
2624         mbuf->frames = gbuffers;
2625         mbuf->size   = gbuffers * gbufsize;
2626
2627         for (i = 0; i < gbuffers; i++)
2628                 mbuf->offsets[i] = i * gbufsize;
2629
2630         mutex_unlock(&fh->cap.vb_lock);
2631         return 0;
2632 }
2633 #endif
2634
2635 static int bttv_querycap(struct file *file, void  *priv,
2636                                 struct v4l2_capability *cap)
2637 {
2638         struct bttv_fh *fh = priv;
2639         struct bttv *btv = fh->btv;
2640
2641         if (0 == v4l2)
2642                 return -EINVAL;
2643
2644         strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2645         strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2646         snprintf(cap->bus_info, sizeof(cap->bus_info),
2647                  "PCI:%s", pci_name(btv->c.pci));
2648         cap->version = BTTV_VERSION_CODE;
2649         cap->capabilities =
2650                 V4L2_CAP_VIDEO_CAPTURE |
2651                 V4L2_CAP_VBI_CAPTURE |
2652                 V4L2_CAP_READWRITE |
2653                 V4L2_CAP_STREAMING;
2654         if (no_overlay <= 0)
2655                 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2656
2657         if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2658             bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2659                 cap->capabilities |= V4L2_CAP_TUNER;
2660         return 0;
2661 }
2662
2663 static int bttv_enum_fmt_vbi(struct file *file, void  *priv,
2664                                 struct v4l2_fmtdesc *f)
2665 {
2666         if (0 != f->index)
2667                 return -EINVAL;
2668
2669         f->pixelformat = V4L2_PIX_FMT_GREY;
2670         strcpy(f->description, "vbi data");
2671
2672         return 0;
2673 }
2674
2675 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2676 {
2677         int index = -1, i;
2678
2679         for (i = 0; i < FORMATS; i++) {
2680                 if (formats[i].fourcc != -1)
2681                         index++;
2682                 if ((unsigned int)index == f->index)
2683                         break;
2684         }
2685         if (FORMATS == i)
2686                 return -EINVAL;
2687
2688         f->pixelformat = formats[i].fourcc;
2689         strlcpy(f->description, formats[i].name, sizeof(f->description));
2690
2691         return i;
2692 }
2693
2694 static int bttv_enum_fmt_cap(struct file *file, void  *priv,
2695                                 struct v4l2_fmtdesc *f)
2696 {
2697         int rc = bttv_enum_fmt_cap_ovr(f);
2698
2699         if (rc < 0)
2700                 return rc;
2701
2702         return 0;
2703 }
2704
2705 static int bttv_enum_fmt_overlay(struct file *file, void  *priv,
2706                                         struct v4l2_fmtdesc *f)
2707 {
2708         int rc;
2709
2710         if (no_overlay > 0) {
2711                 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2712                 return -EINVAL;
2713         }
2714
2715         rc = bttv_enum_fmt_cap_ovr(f);
2716
2717         if (rc < 0)
2718                 return rc;
2719
2720         if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2721                 return -EINVAL;
2722
2723         return 0;
2724 }
2725
2726 static int bttv_g_fbuf(struct file *file, void *f,
2727                                 struct v4l2_framebuffer *fb)
2728 {
2729         struct bttv_fh *fh = f;
2730         struct bttv *btv = fh->btv;
2731
2732         *fb = btv->fbuf;
2733         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2734         if (fh->ovfmt)
2735                 fb->fmt.pixelformat  = fh->ovfmt->fourcc;
2736         return 0;
2737 }
2738
2739 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2740 {
2741         struct bttv_fh *fh = f;
2742         struct bttv *btv = fh->btv;
2743         struct bttv_buffer *new;
2744         int retval;
2745
2746         if (on) {
2747                 /* verify args */
2748                 if (NULL == btv->fbuf.base)
2749                         return -EINVAL;
2750                 if (!fh->ov.setup_ok) {
2751                         dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2752                         return -EINVAL;
2753                 }
2754         }
2755
2756         if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2757                 return -EBUSY;
2758
2759         mutex_lock(&fh->cap.vb_lock);
2760         if (on) {
2761                 fh->ov.tvnorm = btv->tvnorm;
2762                 new = videobuf_pci_alloc(sizeof(*new));
2763                 new->crop = btv->crop[!!fh->do_crop].rect;
2764                 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2765         } else {
2766                 new = NULL;
2767         }
2768
2769         /* switch over */
2770         retval = bttv_switch_overlay(btv, fh, new);
2771         mutex_unlock(&fh->cap.vb_lock);
2772         return retval;
2773 }
2774
2775 static int bttv_s_fbuf(struct file *file, void *f,
2776                                 struct v4l2_framebuffer *fb)
2777 {
2778         struct bttv_fh *fh = f;
2779         struct bttv *btv = fh->btv;
2780         const struct bttv_format *fmt;
2781         int retval;
2782
2783         if (!capable(CAP_SYS_ADMIN) &&
2784                 !capable(CAP_SYS_RAWIO))
2785                 return -EPERM;
2786
2787         /* check args */
2788         fmt = format_by_fourcc(fb->fmt.pixelformat);
2789         if (NULL == fmt)
2790                 return -EINVAL;
2791         if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2792                 return -EINVAL;
2793
2794         retval = -EINVAL;
2795         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2796                 __s32 width = fb->fmt.width;
2797                 __s32 height = fb->fmt.height;
2798
2799                 retval = limit_scaled_size(fh, &width, &height,
2800                                            V4L2_FIELD_INTERLACED,
2801                                            /* width_mask */ ~3,
2802                                            /* width_bias */ 2,
2803                                            /* adjust_size */ 0,
2804                                            /* adjust_crop */ 0);
2805                 if (0 != retval)
2806                         return retval;
2807         }
2808
2809         /* ok, accept it */
2810         mutex_lock(&fh->cap.vb_lock);
2811         btv->fbuf.base       = fb->base;
2812         btv->fbuf.fmt.width  = fb->fmt.width;
2813         btv->fbuf.fmt.height = fb->fmt.height;
2814         if (0 != fb->fmt.bytesperline)
2815                 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2816         else
2817                 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2818
2819         retval = 0;
2820         fh->ovfmt = fmt;
2821         btv->init.ovfmt = fmt;
2822         if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2823                 fh->ov.w.left   = 0;
2824                 fh->ov.w.top    = 0;
2825                 fh->ov.w.width  = fb->fmt.width;
2826                 fh->ov.w.height = fb->fmt.height;
2827                 btv->init.ov.w.width  = fb->fmt.width;
2828                 btv->init.ov.w.height = fb->fmt.height;
2829                         kfree(fh->ov.clips);
2830                 fh->ov.clips = NULL;
2831                 fh->ov.nclips = 0;
2832
2833                 if (check_btres(fh, RESOURCE_OVERLAY)) {
2834                         struct bttv_buffer *new;
2835
2836                         new = videobuf_pci_alloc(sizeof(*new));
2837                         new->crop = btv->crop[!!fh->do_crop].rect;
2838                         bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2839                         retval = bttv_switch_overlay(btv, fh, new);
2840                 }
2841         }
2842         mutex_unlock(&fh->cap.vb_lock);
2843         return retval;
2844 }
2845
2846 static int bttv_reqbufs(struct file *file, void *priv,
2847                                 struct v4l2_requestbuffers *p)
2848 {
2849         struct bttv_fh *fh = priv;
2850         return videobuf_reqbufs(bttv_queue(fh), p);
2851 }
2852
2853 static int bttv_querybuf(struct file *file, void *priv,
2854                                 struct v4l2_buffer *b)
2855 {
2856         struct bttv_fh *fh = priv;
2857         return videobuf_querybuf(bttv_queue(fh), b);
2858 }
2859
2860 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2861 {
2862         struct bttv_fh *fh = priv;
2863         struct bttv *btv = fh->btv;
2864         int res = bttv_resource(fh);
2865
2866         if (!check_alloc_btres(btv, fh, res))
2867                 return -EBUSY;
2868
2869         return videobuf_qbuf(bttv_queue(fh), b);
2870 }
2871
2872 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2873 {
2874         struct bttv_fh *fh = priv;
2875         return videobuf_dqbuf(bttv_queue(fh), b,
2876                         file->f_flags & O_NONBLOCK);
2877 }
2878
2879 static int bttv_streamon(struct file *file, void *priv,
2880                                         enum v4l2_buf_type type)
2881 {
2882         struct bttv_fh *fh = priv;
2883         struct bttv *btv = fh->btv;
2884         int res = bttv_resource(fh);
2885
2886         if (!check_alloc_btres(btv, fh, res))
2887                 return -EBUSY;
2888         return videobuf_streamon(bttv_queue(fh));
2889 }
2890
2891
2892 static int bttv_streamoff(struct file *file, void *priv,
2893                                         enum v4l2_buf_type type)
2894 {
2895         struct bttv_fh *fh = priv;
2896         struct bttv *btv = fh->btv;
2897         int retval;
2898         int res = bttv_resource(fh);
2899
2900
2901         retval = videobuf_streamoff(bttv_queue(fh));
2902         if (retval < 0)
2903                 return retval;
2904         free_btres(btv, fh, res);
2905         return 0;
2906 }
2907
2908 static int bttv_queryctrl(struct file *file, void *priv,
2909                                         struct v4l2_queryctrl *c)
2910 {
2911         struct bttv_fh *fh = priv;
2912         struct bttv *btv = fh->btv;
2913         const struct v4l2_queryctrl *ctrl;
2914
2915         if ((c->id <  V4L2_CID_BASE ||
2916              c->id >= V4L2_CID_LASTP1) &&
2917             (c->id <  V4L2_CID_PRIVATE_BASE ||
2918              c->id >= V4L2_CID_PRIVATE_LASTP1))
2919                 return -EINVAL;
2920
2921         if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2922                 *c = no_ctl;
2923         else {
2924                 ctrl = ctrl_by_id(c->id);
2925
2926                 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2927         }
2928
2929         return 0;
2930 }
2931
2932 static int bttv_g_parm(struct file *file, void *f,
2933                                 struct v4l2_streamparm *parm)
2934 {
2935         struct bttv_fh *fh = f;
2936         struct bttv *btv = fh->btv;
2937         struct v4l2_standard s;
2938
2939         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2940                 return -EINVAL;
2941         v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2942                                  bttv_tvnorms[btv->tvnorm].name);
2943         parm->parm.capture.timeperframe = s.frameperiod;
2944         return 0;
2945 }
2946
2947 static int bttv_g_tuner(struct file *file, void *priv,
2948                                 struct v4l2_tuner *t)
2949 {
2950         struct bttv_fh *fh = priv;
2951         struct bttv *btv = fh->btv;
2952
2953         if (UNSET == bttv_tvcards[btv->c.type].tuner)
2954                 return -EINVAL;
2955         if (0 != t->index)
2956                 return -EINVAL;
2957
2958         mutex_lock(&btv->lock);
2959         memset(t, 0, sizeof(*t));
2960         t->rxsubchans = V4L2_TUNER_SUB_MONO;
2961         bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
2962         strcpy(t->name, "Television");
2963         t->capability = V4L2_TUNER_CAP_NORM;
2964         t->type       = V4L2_TUNER_ANALOG_TV;
2965         if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2966                 t->signal = 0xffff;
2967
2968         if (btv->audio_mode_gpio)
2969                 btv->audio_mode_gpio(btv, t, 0);
2970
2971         mutex_unlock(&btv->lock);
2972         return 0;
2973 }
2974
2975 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2976 {
2977         struct bttv_fh *fh = f;
2978         struct bttv *btv = fh->btv;
2979
2980         *p = v4l2_prio_max(&btv->prio);
2981
2982         return 0;
2983 }
2984
2985 static int bttv_s_priority(struct file *file, void *f,
2986                                         enum v4l2_priority prio)
2987 {
2988         struct bttv_fh *fh = f;
2989         struct bttv *btv = fh->btv;
2990
2991         return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2992 }
2993
2994 static int bttv_cropcap(struct file *file, void *priv,
2995                                 struct v4l2_cropcap *cap)
2996 {
2997         struct bttv_fh *fh = priv;
2998         struct bttv *btv = fh->btv;
2999
3000         if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3001             cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3002                 return -EINVAL;
3003
3004         *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3005
3006         return 0;
3007 }
3008
3009 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
3010 {
3011         struct bttv_fh *fh = f;
3012         struct bttv *btv = fh->btv;
3013
3014         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3015             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3016                 return -EINVAL;
3017
3018         /* No fh->do_crop = 1; because btv->crop[1] may be
3019            inconsistent with fh->width or fh->height and apps
3020            do not expect a change here. */
3021
3022         crop->c = btv->crop[!!fh->do_crop].rect;
3023
3024         return 0;
3025 }
3026
3027 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3028 {
3029         struct bttv_fh *fh = f;
3030         struct bttv *btv = fh->btv;
3031         const struct v4l2_rect *b;
3032         int retval;
3033         struct bttv_crop c;
3034         __s32 b_left;
3035         __s32 b_top;
3036         __s32 b_right;
3037         __s32 b_bottom;
3038
3039         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3040             crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3041                 return -EINVAL;
3042
3043         retval = v4l2_prio_check(&btv->prio, &fh->prio);
3044         if (0 != retval)
3045                 return retval;
3046
3047         /* Make sure tvnorm, vbi_end and the current cropping
3048            parameters remain consistent until we're done. Note
3049            read() may change vbi_end in check_alloc_btres(). */
3050         mutex_lock(&btv->lock);
3051
3052         retval = -EBUSY;
3053
3054         if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3055                 mutex_unlock(&btv->lock);
3056                 return retval;
3057         }
3058
3059         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3060
3061         b_left = b->left;
3062         b_right = b_left + b->width;
3063         b_bottom = b->top + b->height;
3064
3065         b_top = max(b->top, btv->vbi_end);
3066         if (b_top + 32 >= b_bottom) {
3067                 mutex_unlock(&btv->lock);
3068                 return retval;
3069         }
3070
3071         /* Min. scaled size 48 x 32. */
3072         c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3073         c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3074
3075         c.rect.width = clamp(crop->c.width,
3076                              48, b_right - c.rect.left);
3077
3078         c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3079         /* Top and height must be a multiple of two. */
3080         c.rect.top = (c.rect.top + 1) & ~1;
3081
3082         c.rect.height = clamp(crop->c.height,
3083                               32, b_bottom - c.rect.top);
3084         c.rect.height = (c.rect.height + 1) & ~1;
3085
3086         bttv_crop_calc_limits(&c);
3087
3088         btv->crop[1] = c;
3089
3090         mutex_unlock(&btv->lock);
3091
3092         fh->do_crop = 1;
3093
3094         mutex_lock(&fh->cap.vb_lock);
3095
3096         if (fh->width < c.min_scaled_width) {
3097                 fh->width = c.min_scaled_width;
3098                 btv->init.width = c.min_scaled_width;
3099         } else if (fh->width > c.max_scaled_width) {
3100                 fh->width = c.max_scaled_width;
3101                 btv->init.width = c.max_scaled_width;
3102         }
3103
3104         if (fh->height < c.min_scaled_height) {
3105                 fh->height = c.min_scaled_height;
3106                 btv->init.height = c.min_scaled_height;
3107         } else if (fh->height > c.max_scaled_height) {
3108                 fh->height = c.max_scaled_height;
3109                 btv->init.height = c.max_scaled_height;
3110         }
3111
3112         mutex_unlock(&fh->cap.vb_lock);
3113
3114         return 0;
3115 }
3116
3117 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3118 {
3119         strcpy(a->name, "audio");
3120         return 0;
3121 }
3122
3123 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3124 {
3125         return 0;
3126 }
3127
3128 static ssize_t bttv_read(struct file *file, char __user *data,
3129                          size_t count, loff_t *ppos)
3130 {
3131         struct bttv_fh *fh = file->private_data;
3132         int retval = 0;
3133
3134         if (fh->btv->errors)
3135                 bttv_reinit_bt848(fh->btv);
3136         dprintk("bttv%d: read count=%d type=%s\n",
3137                 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3138
3139         switch (fh->type) {
3140         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3141                 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3142                         /* VIDEO_READ in use by another fh,
3143                            or VIDEO_STREAM by any fh. */
3144                         return -EBUSY;
3145                 }
3146                 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3147                                            file->f_flags & O_NONBLOCK);
3148                 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3149                 break;
3150         case V4L2_BUF_TYPE_VBI_CAPTURE:
3151                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3152                         return -EBUSY;
3153                 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3154                                               file->f_flags & O_NONBLOCK);
3155                 break;
3156         default:
3157                 BUG();
3158         }
3159         return retval;
3160 }
3161
3162 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3163 {
3164         struct bttv_fh *fh = file->private_data;
3165         struct bttv_buffer *buf;
3166         enum v4l2_field field;
3167
3168         if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3169                 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3170                         return POLLERR;
3171                 return videobuf_poll_stream(file, &fh->vbi, wait);
3172         }
3173
3174         if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3175                 /* streaming capture */
3176                 if (list_empty(&fh->cap.stream))
3177                         return POLLERR;
3178                 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3179         } else {
3180                 /* read() capture */
3181                 mutex_lock(&fh->cap.vb_lock);
3182                 if (NULL == fh->cap.read_buf) {
3183                         /* need to capture a new frame */
3184                         if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3185                                 goto err;
3186                         fh->cap.read_buf = videobuf_pci_alloc(fh->cap.msize);
3187                         if (NULL == fh->cap.read_buf)
3188                                 goto err;
3189                         fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3190                         field = videobuf_next_field(&fh->cap);
3191                         if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3192                                 kfree (fh->cap.read_buf);
3193                                 fh->cap.read_buf = NULL;
3194                                 goto err;
3195                         }
3196                         fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3197                         fh->cap.read_off = 0;
3198                 }
3199                 mutex_unlock(&fh->cap.vb_lock);
3200                 buf = (struct bttv_buffer*)fh->cap.read_buf;
3201         }
3202
3203         poll_wait(file, &buf->vb.done, wait);
3204         if (buf->vb.state == VIDEOBUF_DONE ||
3205             buf->vb.state == VIDEOBUF_ERROR)
3206                 return POLLIN|POLLRDNORM;
3207         return 0;
3208 err:
3209         mutex_unlock(&fh->cap.vb_lock);
3210         return POLLERR;
3211 }
3212
3213 static int bttv_open(struct inode *inode, struct file *file)
3214 {
3215         int minor = iminor(inode);
3216         struct bttv *btv = NULL;
3217         struct bttv_fh *fh;
3218         enum v4l2_buf_type type = 0;
3219         unsigned int i;
3220
3221         dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3222
3223         for (i = 0; i < bttv_num; i++) {
3224                 if (bttvs[i].video_dev &&
3225                     bttvs[i].video_dev->minor == minor) {
3226                         btv = &bttvs[i];
3227                         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3228                         break;
3229                 }
3230                 if (bttvs[i].vbi_dev &&
3231                     bttvs[i].vbi_dev->minor == minor) {
3232                         btv = &bttvs[i];
3233                         type = V4L2_BUF_TYPE_VBI_CAPTURE;
3234                         break;
3235                 }
3236         }
3237         if (NULL == btv)
3238                 return -ENODEV;
3239
3240         dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3241                 btv->c.nr,v4l2_type_names[type]);
3242
3243         /* allocate per filehandle data */
3244         fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3245         if (NULL == fh)
3246                 return -ENOMEM;
3247         file->private_data = fh;
3248         *fh = btv->init;
3249         fh->type = type;
3250         fh->ov.setup_ok = 0;
3251         v4l2_prio_open(&btv->prio,&fh->prio);
3252
3253         videobuf_queue_pci_init(&fh->cap, &bttv_video_qops,
3254                             btv->c.pci, &btv->s_lock,
3255                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
3256                             V4L2_FIELD_INTERLACED,
3257                             sizeof(struct bttv_buffer),
3258                             fh);
3259         videobuf_queue_pci_init(&fh->vbi, &bttv_vbi_qops,
3260                             btv->c.pci, &btv->s_lock,
3261                             V4L2_BUF_TYPE_VBI_CAPTURE,
3262                             V4L2_FIELD_SEQ_TB,
3263                             sizeof(struct bttv_buffer),
3264                             fh);
3265         set_tvnorm(btv,btv->tvnorm);
3266
3267         btv->users++;
3268
3269         /* The V4L2 spec requires one global set of cropping parameters
3270            which only change on request. These are stored in btv->crop[1].
3271            However for compatibility with V4L apps and cropping unaware
3272            V4L2 apps we now reset the cropping parameters as seen through
3273            this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3274            will use btv->crop[0], the default cropping parameters for the
3275            current video standard, and VIDIOC_S_FMT will not implicitely
3276            change the cropping parameters until VIDIOC_S_CROP has been
3277            called. */
3278         fh->do_crop = !reset_crop; /* module parameter */
3279
3280         /* Likewise there should be one global set of VBI capture
3281            parameters, but for compatibility with V4L apps and earlier
3282            driver versions each fh has its own parameters. */
3283         bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3284
3285         bttv_field_count(btv);
3286         return 0;
3287 }
3288
3289 static int bttv_release(struct inode *inode, struct file *file)
3290 {
3291         struct bttv_fh *fh = file->private_data;
3292         struct bttv *btv = fh->btv;
3293
3294         /* turn off overlay */
3295         if (check_btres(fh, RESOURCE_OVERLAY))
3296                 bttv_switch_overlay(btv,fh,NULL);
3297
3298         /* stop video capture */
3299         if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3300                 videobuf_streamoff(&fh->cap);
3301                 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3302         }
3303         if (fh->cap.read_buf) {
3304                 buffer_release(&fh->cap,fh->cap.read_buf);
3305                 kfree(fh->cap.read_buf);
3306         }
3307         if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3308                 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3309         }
3310
3311         /* stop vbi capture */
3312         if (check_btres(fh, RESOURCE_VBI)) {
3313                 videobuf_stop(&fh->vbi);
3314                 free_btres(btv,fh,RESOURCE_VBI);
3315         }
3316
3317         /* free stuff */
3318         videobuf_mmap_free(&fh->cap);
3319         videobuf_mmap_free(&fh->vbi);
3320         v4l2_prio_close(&btv->prio,&fh->prio);
3321         file->private_data = NULL;
3322         kfree(fh);
3323
3324         btv->users--;
3325         bttv_field_count(btv);
3326         return 0;
3327 }
3328
3329 static int
3330 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3331 {
3332         struct bttv_fh *fh = file->private_data;
3333
3334         dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3335                 fh->btv->c.nr, v4l2_type_names[fh->type],
3336                 vma->vm_start, vma->vm_end - vma->vm_start);
3337         return videobuf_mmap_mapper(bttv_queue(fh),vma);
3338 }
3339
3340 static const struct file_operations bttv_fops =
3341 {
3342         .owner    = THIS_MODULE,
3343         .open     = bttv_open,
3344         .release  = bttv_release,
3345         .ioctl    = video_ioctl2,
3346         .compat_ioctl   = v4l_compat_ioctl32,
3347         .llseek   = no_llseek,
3348         .read     = bttv_read,
3349         .mmap     = bttv_mmap,
3350         .poll     = bttv_poll,
3351 };
3352
3353 static struct video_device bttv_video_template =
3354 {
3355         .fops     = &bttv_fops,
3356         .minor    = -1,
3357         .vidioc_querycap                = bttv_querycap,
3358         .vidioc_enum_fmt_cap            = bttv_enum_fmt_cap,
3359         .vidioc_g_fmt_cap               = bttv_g_fmt_cap,
3360         .vidioc_try_fmt_cap             = bttv_try_fmt_cap,
3361         .vidioc_s_fmt_cap               = bttv_s_fmt_cap,
3362         .vidioc_enum_fmt_overlay        = bttv_enum_fmt_overlay,
3363         .vidioc_g_fmt_overlay           = bttv_g_fmt_overlay,
3364         .vidioc_try_fmt_overlay         = bttv_try_fmt_overlay,
3365         .vidioc_s_fmt_overlay           = bttv_s_fmt_overlay,
3366         .vidioc_enum_fmt_vbi            = bttv_enum_fmt_vbi,
3367         .vidioc_g_fmt_vbi               = bttv_g_fmt_vbi,
3368         .vidioc_try_fmt_vbi             = bttv_try_fmt_vbi,
3369         .vidioc_s_fmt_vbi               = bttv_s_fmt_vbi,
3370         .vidioc_g_audio                 = bttv_g_audio,
3371         .vidioc_s_audio                 = bttv_s_audio,
3372         .vidioc_cropcap                 = bttv_cropcap,
3373         .vidioc_reqbufs                 = bttv_reqbufs,
3374         .vidioc_querybuf                = bttv_querybuf,
3375         .vidioc_qbuf                    = bttv_qbuf,
3376         .vidioc_dqbuf                   = bttv_dqbuf,
3377         .vidioc_s_std                   = bttv_s_std,
3378         .vidioc_enum_input              = bttv_enum_input,
3379         .vidioc_g_input                 = bttv_g_input,
3380         .vidioc_s_input                 = bttv_s_input,
3381         .vidioc_queryctrl               = bttv_queryctrl,
3382         .vidioc_g_ctrl                  = bttv_g_ctrl,
3383         .vidioc_s_ctrl                  = bttv_s_ctrl,
3384         .vidioc_streamon                = bttv_streamon,
3385         .vidioc_streamoff               = bttv_streamoff,
3386         .vidioc_g_tuner                 = bttv_g_tuner,
3387         .vidioc_s_tuner                 = bttv_s_tuner,
3388 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3389         .vidiocgmbuf                    = vidiocgmbuf,
3390 #endif
3391         .vidioc_g_crop                  = bttv_g_crop,
3392         .vidioc_g_crop                  = bttv_g_crop,
3393         .vidioc_s_crop                  = bttv_s_crop,
3394         .vidioc_g_fbuf                  = bttv_g_fbuf,
3395         .vidioc_s_fbuf                  = bttv_s_fbuf,
3396         .vidioc_overlay                 = bttv_overlay,
3397         .vidioc_g_priority              = bttv_g_priority,
3398         .vidioc_s_priority              = bttv_s_priority,
3399         .vidioc_g_parm                  = bttv_g_parm,
3400         .vidioc_g_frequency             = bttv_g_frequency,
3401         .vidioc_s_frequency             = bttv_s_frequency,
3402         .vidioc_log_status              = bttv_log_status,
3403         .vidioc_querystd                = bttv_querystd,
3404 #ifdef CONFIG_VIDEO_ADV_DEBUG
3405         .vidioc_g_register              = bttv_g_register,
3406         .vidioc_s_register              = bttv_s_register,
3407 #endif
3408         .tvnorms                        = BTTV_NORMS,
3409         .current_norm                   = V4L2_STD_PAL,
3410 };
3411
3412 /* ----------------------------------------------------------------------- */
3413 /* radio interface                                                         */
3414
3415 static int radio_open(struct inode *inode, struct file *file)
3416 {
3417         int minor = iminor(inode);
3418         struct bttv *btv = NULL;
3419         unsigned int i;
3420
3421         dprintk("bttv: open minor=%d\n",minor);
3422
3423         for (i = 0; i < bttv_num; i++) {
3424                 if (bttvs[i].radio_dev->minor == minor) {
3425                         btv = &bttvs[i];
3426                         break;
3427                 }
3428         }
3429         if (NULL == btv)
3430                 return -ENODEV;
3431
3432         dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3433         mutex_lock(&btv->lock);
3434
3435         btv->radio_user++;
3436
3437         file->private_data = btv;
3438
3439         bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3440         audio_input(btv,TVAUDIO_INPUT_RADIO);
3441
3442         mutex_unlock(&btv->lock);
3443         return 0;
3444 }
3445
3446 static int radio_release(struct inode *inode, struct file *file)
3447 {
3448         struct bttv *btv = file->private_data;
3449         struct rds_command cmd;
3450
3451         btv->radio_user--;
3452
3453         bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3454
3455         return 0;
3456 }
3457
3458 static int radio_querycap(struct file *file, void *priv,
3459                                         struct v4l2_capability *cap)
3460 {
3461         struct bttv_fh *fh = priv;
3462         struct bttv *btv = fh->btv;
3463
3464         strcpy(cap->driver, "bttv");
3465         strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3466         sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3467         cap->version = BTTV_VERSION_CODE;
3468         cap->capabilities = V4L2_CAP_TUNER;
3469
3470         return 0;
3471 }
3472