Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/media/pci/bt8xx/bttv-driver.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us