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

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