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