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    VBI           VIDIOC_STREAMON             VIDIOC_STREAMOFF
 628                  VIDIOC_QBUF 1)              bttv_release
 629                  bttv_read, bttv_poll 1) 3)
 630
 631    1) The resource must be allocated when we enter buffer prepare functions
 632       and remain allocated while buffers are in the DMA queue.
 633    2) This is a single frame read.
 634    3) This is a continuous read, implies VIDIOC_STREAMON.
 635
 636    Note this driver permits video input and standard changes regardless if
 637    resources are allocated.
 638 */
 639
 640 #define VBI_RESOURCES (RESOURCE_VBI)
 641 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
 642                          RESOURCE_VIDEO_STREAM)
 643
 644 int check_alloc_btres_lock(struct bttv *btv, int bit)
 645 {
 646         int xbits; /* mutual exclusive resources */
 647
 648         xbits = bit;
 649         if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
 650                 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
 651
 652         /* is it free? */
 653         if (btv->resources & xbits) {
 654                 /* no, someone else uses it */
 655                 goto fail;
 656         }
 657
 658         if ((bit & VIDEO_RESOURCES)
 659             && 0 == (btv->resources & VIDEO_RESOURCES)) {
 660                 /* Do crop - use current, don't - use default parameters. */
 661                 __s32 top = btv->crop[!!btv->do_crop].rect.top;
 662
 663                 if (btv->vbi_end > top)
 664                         goto fail;
 665
 666                 /* We cannot capture the same line as video and VBI data.
 667                    Claim scan lines crop[].rect.top to bottom. */
 668                 btv->crop_start = top;
 669         } else if (bit & VBI_RESOURCES) {
 670                 __s32 end = btv->vbi_fmt.end;
 671
 672                 if (end > btv->crop_start)
 673                         goto fail;
 674
 675                 /* Claim scan lines above btv->vbi_fmt.end. */
 676                 btv->vbi_end = end;
 677         }
 678
 679         /* it's free, grab it */
 680         btv->resources |= bit;
 681         return 1;
 682
 683  fail:
 684         return 0;
 685 }
 686
 687 static
 688 int check_btres(struct bttv *btv, int bit)
 689 {
 690         return (btv->resources & bit);
 691 }
 692
 693 static
 694 int locked_btres(struct bttv *btv, int bit)
 695 {
 696         return (btv->resources & bit);
 697 }
 698
 699 /* Call with btv->lock down. */
 700 static void
 701 disclaim_vbi_lines(struct bttv *btv)
 702 {
 703         btv->vbi_end = 0;
 704 }
 705
 706 /* Call with btv->lock down. */
 707 static void
 708 disclaim_video_lines(struct bttv *btv)
 709 {
 710         const struct bttv_tvnorm *tvnorm;
 711         u8 crop;
 712
 713         tvnorm = &bttv_tvnorms[btv->tvnorm];
 714         btv->crop_start = tvnorm->cropcap.bounds.top
 715                 + tvnorm->cropcap.bounds.height;
 716
 717         /* VBI capturing ends at VDELAY, start of video capturing, no
 718            matter how many lines the VBI RISC program expects. When video
 719            capturing is off, it shall no longer "preempt" VBI capturing,
 720            so we set VDELAY to maximum. */
 721         crop = btread(BT848_E_CROP) | 0xc0;
 722         btwrite(crop, BT848_E_CROP);
 723         btwrite(0xfe, BT848_E_VDELAY_LO);
 724         btwrite(crop, BT848_O_CROP);
 725         btwrite(0xfe, BT848_O_VDELAY_LO);
 726 }
 727
 728 void free_btres_lock(struct bttv *btv, int bits)
 729 {
 730         if ((btv->resources & bits) != bits) {
 731                 /* trying to free resources not allocated by us ... */
 732                 pr_err("BUG! (btres)\n");
 733         }
 734         btv->resources &= ~bits;
 735
 736         bits = btv->resources;
 737
 738         if (0 == (bits & VIDEO_RESOURCES))
 739                 disclaim_video_lines(btv);
 740
 741         if (0 == (bits & VBI_RESOURCES))
 742                 disclaim_vbi_lines(btv);
 743 }
 744
 745 /* ----------------------------------------------------------------------- */
 746 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC          */
 747
 748 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
 749    PLL_X = Reference pre-divider (0=1, 1=2)
 750    PLL_C = Post divider (0=6, 1=4)
 751    PLL_I = Integer input
 752    PLL_F = Fractional input
 753
 754    F_input = 28.636363 MHz:
 755    PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
 756 */
 757
 758 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
 759 {
 760         unsigned char fl, fh, fi;
 761
 762         /* prevent overflows */
 763         fin/=4;
 764         fout/=4;
 765
 766         fout*=12;
 767         fi=fout/fin;
 768
 769         fout=(fout%fin)*256;
 770         fh=fout/fin;
 771
 772         fout=(fout%fin)*256;
 773         fl=fout/fin;
 774
 775         btwrite(fl, BT848_PLL_F_LO);
 776         btwrite(fh, BT848_PLL_F_HI);
 777         btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
 778 }
 779
 780 static void set_pll(struct bttv *btv)
 781 {
 782         int i;
 783
 784         if (!btv->pll.pll_crystal)
 785                 return;
 786
 787         if (btv->pll.pll_ofreq == btv->pll.pll_current) {
 788                 dprintk("%d: PLL: no change required\n", btv->c.nr);
 789                 return;
 790         }
 791
 792         if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
 793                 /* no PLL needed */
 794                 if (btv->pll.pll_current == 0)
 795                         return;
 796                 if (bttv_verbose)
 797                         pr_info("%d: PLL can sleep, using XTAL (%d)\n",
 798                                 btv->c.nr, btv->pll.pll_ifreq);
 799                 btwrite(0x00,BT848_TGCTRL);
 800                 btwrite(0x00,BT848_PLL_XCI);
 801                 btv->pll.pll_current = 0;
 802                 return;
 803         }
 804
 805         if (bttv_verbose)
 806                 pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n",
 807                         btv->c.nr,
 808                         btv->pll.pll_ifreq, btv->pll.pll_ofreq);
 809         set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
 810
 811         for (i=0; i<10; i++) {
 812                 /*  Let other people run while the PLL stabilizes */
 813                 msleep(10);
 814
 815                 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
 816                         btwrite(0,BT848_DSTATUS);
 817                 } else {
 818                         btwrite(0x08,BT848_TGCTRL);
 819                         btv->pll.pll_current = btv->pll.pll_ofreq;
 820                         if (bttv_verbose)
 821                                 pr_info("PLL set ok\n");
 822                         return;
 823                 }
 824         }
 825         btv->pll.pll_current = -1;
 826         if (bttv_verbose)
 827                 pr_info("Setting PLL failed\n");
 828         return;
 829 }
 830
 831 /* used to switch between the bt848's analog/digital video capture modes */
 832 static void bt848A_set_timing(struct bttv *btv)
 833 {
 834         int i, len;
 835         int table_idx = bttv_tvnorms[btv->tvnorm].sram;
 836         int fsc       = bttv_tvnorms[btv->tvnorm].Fsc;
 837
 838         if (btv->input == btv->dig) {
 839                 dprintk("%d: load digital timing table (table_idx=%d)\n",
 840                         btv->c.nr,table_idx);
 841
 842                 /* timing change...reset timing generator address */
 843                 btwrite(0x00, BT848_TGCTRL);
 844                 btwrite(0x02, BT848_TGCTRL);
 845                 btwrite(0x00, BT848_TGCTRL);
 846
 847                 len=SRAM_Table[table_idx][0];
 848                 for(i = 1; i <= len; i++)
 849                         btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
 850                 btv->pll.pll_ofreq = 27000000;
 851
 852                 set_pll(btv);
 853                 btwrite(0x11, BT848_TGCTRL);
 854                 btwrite(0x41, BT848_DVSIF);
 855         } else {
 856                 btv->pll.pll_ofreq = fsc;
 857                 set_pll(btv);
 858                 btwrite(0x0, BT848_DVSIF);
 859         }
 860 }
 861
 862 /* ----------------------------------------------------------------------- */
 863
 864 static void bt848_bright(struct bttv *btv, int bright)
 865 {
 866         int value;
 867
 868         // printk("set bright: %d\n", bright); // DEBUG
 869         btv->bright = bright;
 870
 871         /* We want -128 to 127 we get 0-65535 */
 872         value = (bright >> 8) - 128;
 873         btwrite(value & 0xff, BT848_BRIGHT);
 874 }
 875
 876 static void bt848_hue(struct bttv *btv, int hue)
 877 {
 878         int value;
 879
 880         btv->hue = hue;
 881
 882         /* -128 to 127 */
 883         value = (hue >> 8) - 128;
 884         btwrite(value & 0xff, BT848_HUE);
 885 }
 886
 887 static void bt848_contrast(struct bttv *btv, int cont)
 888 {
 889         int value,hibit;
 890
 891         btv->contrast = cont;
 892
 893         /* 0-511 */
 894         value = (cont  >> 7);
 895         hibit = (value >> 6) & 4;
 896         btwrite(value & 0xff, BT848_CONTRAST_LO);
 897         btaor(hibit, ~4, BT848_E_CONTROL);
 898         btaor(hibit, ~4, BT848_O_CONTROL);
 899 }
 900
 901 static void bt848_sat(struct bttv *btv, int color)
 902 {
 903         int val_u,val_v,hibits;
 904
 905         btv->saturation = color;
 906
 907         /* 0-511 for the color */
 908         val_u   = ((color * btv->opt_uv_ratio) / 50) >> 7;
 909         val_v   = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
 910         hibits  = (val_u >> 7) & 2;
 911         hibits |= (val_v >> 8) & 1;
 912         btwrite(val_u & 0xff, BT848_SAT_U_LO);
 913         btwrite(val_v & 0xff, BT848_SAT_V_LO);
 914         btaor(hibits, ~3, BT848_E_CONTROL);
 915         btaor(hibits, ~3, BT848_O_CONTROL);
 916 }
 917
 918 /* ----------------------------------------------------------------------- */
 919
 920 static int
 921 video_mux(struct bttv *btv, unsigned int input)
 922 {
 923         int mux,mask2;
 924
 925         if (input >= bttv_tvcards[btv->c.type].video_inputs)
 926                 return -EINVAL;
 927
 928         /* needed by RemoteVideo MX */
 929         mask2 = bttv_tvcards[btv->c.type].gpiomask2;
 930         if (mask2)
 931                 gpio_inout(mask2,mask2);
 932
 933         if (input == btv->svhs)  {
 934                 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
 935                 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
 936         } else {
 937                 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
 938                 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
 939         }
 940         mux = bttv_muxsel(btv, input);
 941         btaor(mux<<5, ~(3<<5), BT848_IFORM);
 942         dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux);
 943
 944         /* card specific hook */
 945         if(bttv_tvcards[btv->c.type].muxsel_hook)
 946                 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
 947         return 0;
 948 }
 949
 950 static char *audio_modes[] = {
 951         "audio: tuner", "audio: radio", "audio: extern",
 952         "audio: intern", "audio: mute"
 953 };
 954
 955 static void
 956 audio_mux_gpio(struct bttv *btv, int input, int mute)
 957 {
 958         int gpio_val, signal, mute_gpio;
 959
 960         gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
 961                    bttv_tvcards[btv->c.type].gpiomask);
 962         signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
 963
 964         /* automute */
 965         mute_gpio = mute || (btv->opt_automute && (!signal || !btv->users)
 966                                 && !btv->has_radio_tuner);
 967
 968         if (mute_gpio)
 969                 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
 970         else
 971                 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
 972
 973         switch (btv->c.type) {
 974         case BTTV_BOARD_VOODOOTV_FM:
 975         case BTTV_BOARD_VOODOOTV_200:
 976                 gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
 977                 break;
 978
 979         default:
 980                 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
 981         }
 982
 983         if (bttv_gpio)
 984                 bttv_gpio_tracking(btv, audio_modes[mute_gpio ? 4 : input]);
 985 }
 986
 987 static int
 988 audio_mute(struct bttv *btv, int mute)
 989 {
 990         struct v4l2_ctrl *ctrl;
 991
 992         audio_mux_gpio(btv, btv->audio_input, mute);
 993
 994         if (btv->sd_msp34xx) {
 995                 ctrl = v4l2_ctrl_find(btv->sd_msp34xx->ctrl_handler, V4L2_CID_AUDIO_MUTE);
 996                 if (ctrl)
 997                         v4l2_ctrl_s_ctrl(ctrl, mute);
 998         }
 999         if (btv->sd_tvaudio) {
1000                 ctrl = v4l2_ctrl_find(btv->sd_tvaudio->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1001                 if (ctrl)
1002                         v4l2_ctrl_s_ctrl(ctrl, mute);
1003         }
1004         if (btv->sd_tda7432) {
1005                 ctrl = v4l2_ctrl_find(btv->sd_tda7432->ctrl_handler, V4L2_CID_AUDIO_MUTE);
1006                 if (ctrl)
1007                         v4l2_ctrl_s_ctrl(ctrl, mute);
1008         }
1009         return 0;
1010 }
1011
1012 static int
1013 audio_input(struct bttv *btv, int input)
1014 {
1015         audio_mux_gpio(btv, input, btv->mute);
1016
1017         if (btv->sd_msp34xx) {
1018                 u32 in;
1019
1020                 /* Note: the inputs tuner/radio/extern/intern are translated
1021                    to msp routings. This assumes common behavior for all msp3400
1022                    based TV cards. When this assumption fails, then the
1023                    specific MSP routing must be added to the card table.
1024                    For now this is sufficient. */
1025                 switch (input) {
1026                 case TVAUDIO_INPUT_RADIO:
1027                         /* Some boards need the msp do to the radio demod */
1028                         if (btv->radio_uses_msp_demodulator) {
1029                                 in = MSP_INPUT_DEFAULT;
1030                                 break;
1031                         }
1032                         in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1033                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1034                         break;
1035                 case TVAUDIO_INPUT_EXTERN:
1036                         in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1037                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1038                         break;
1039                 case TVAUDIO_INPUT_INTERN:
1040                         /* Yes, this is the same input as for RADIO. I doubt
1041                            if this is ever used. The only board with an INTERN
1042                            input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1043                            that was tested. My guess is that the whole INTERN
1044                            input does not work. */
1045                         in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1046                                     MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1047                         break;
1048                 case TVAUDIO_INPUT_TUNER:
1049                 default:
1050                         /* This is the only card that uses TUNER2, and afaik,
1051                            is the only difference between the VOODOOTV_FM
1052                            and VOODOOTV_200 */
1053                         if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1054                                 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1055                                         MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1056                         else
1057                                 in = MSP_INPUT_DEFAULT;
1058                         break;
1059                 }
1060                 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1061                                in, MSP_OUTPUT_DEFAULT, 0);
1062         }
1063         if (btv->sd_tvaudio) {
1064                 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1065                                  input, 0, 0);
1066         }
1067         return 0;
1068 }
1069
1070 static void
1071 bttv_crop_calc_limits(struct bttv_crop *c)
1072 {
1073         /* Scale factor min. 1:1, max. 16:1. Min. image size
1074            48 x 32. Scaled width must be a multiple of 4. */
1075
1076         if (1) {
1077                 /* For bug compatibility with VIDIOCGCAP and image
1078                    size checks in earlier driver versions. */
1079                 c->min_scaled_width = 48;
1080                 c->min_scaled_height = 32;
1081         } else {
1082                 c->min_scaled_width =
1083                         (max_t(unsigned int, 48, c->rect.width >> 4) + 3) & ~3;
1084                 c->min_scaled_height =
1085                         max_t(unsigned int, 32, c->rect.height >> 4);
1086         }
1087
1088         c->max_scaled_width  = c->rect.width & ~3;
1089         c->max_scaled_height = c->rect.height;
1090 }
1091
1092 static void
1093 bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1094 {
1095         c->rect = bttv_tvnorms[norm].cropcap.defrect;
1096         bttv_crop_calc_limits(c);
1097 }
1098
1099 /* Call with btv->lock down. */
1100 static int
1101 set_tvnorm(struct bttv *btv, unsigned int norm)
1102 {
1103         const struct bttv_tvnorm *tvnorm;
1104         v4l2_std_id id;
1105
1106         WARN_ON(norm >= BTTV_TVNORMS);
1107         WARN_ON(btv->tvnorm >= BTTV_TVNORMS);
1108
1109         tvnorm = &bttv_tvnorms[norm];
1110
1111         if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1112                     sizeof (tvnorm->cropcap))) {
1113                 bttv_crop_reset(&btv->crop[0], norm);
1114                 btv->crop[1] = btv->crop[0]; /* current = default */
1115
1116                 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1117                         btv->crop_start = tvnorm->cropcap.bounds.top
1118                                 + tvnorm->cropcap.bounds.height;
1119                 }
1120         }
1121
1122         btv->tvnorm = norm;
1123
1124         btwrite(tvnorm->adelay, BT848_ADELAY);
1125         btwrite(tvnorm->bdelay, BT848_BDELAY);
1126         btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1127               BT848_IFORM);
1128         btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1129         btwrite(1, BT848_VBI_PACK_DEL);
1130         bt848A_set_timing(btv);
1131
1132         switch (btv->c.type) {
1133         case BTTV_BOARD_VOODOOTV_FM:
1134         case BTTV_BOARD_VOODOOTV_200:
1135                 bttv_tda9880_setnorm(btv, gpio_read());
1136                 break;
1137         }
1138         id = tvnorm->v4l2_id;
1139         bttv_call_all(btv, video, s_std, id);
1140
1141         return 0;
1142 }
1143
1144 /* Call with btv->lock down. */
1145 static void
1146 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1147 {
1148         unsigned long flags;
1149
1150         btv->input = input;
1151         if (irq_iswitch) {
1152                 spin_lock_irqsave(&btv->s_lock,flags);
1153                 if (btv->curr.frame_irq) {
1154                         /* active capture -> delayed input switch */
1155                         btv->new_input = input;
1156                 } else {
1157                         video_mux(btv,input);
1158                 }
1159                 spin_unlock_irqrestore(&btv->s_lock,flags);
1160         } else {
1161                 video_mux(btv,input);
1162         }
1163         btv->audio_input = (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1164                                 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN;
1165         audio_input(btv, btv->audio_input);
1166         set_tvnorm(btv, norm);
1167 }
1168
1169 void init_irqreg(struct bttv *btv)
1170 {
1171         /* clear status */
1172         btwrite(0xfffffUL, BT848_INT_STAT);
1173
1174         if (bttv_tvcards[btv->c.type].no_video) {
1175                 /* i2c only */
1176                 btwrite(BT848_INT_I2CDONE,
1177                         BT848_INT_MASK);
1178         } else {
1179                 /* full video */
1180                 btwrite((btv->triton1)  |
1181                         (btv->gpioirq ? BT848_INT_GPINT : 0) |
1182                         BT848_INT_SCERR |
1183                         (fdsr ? BT848_INT_FDSR : 0) |
1184                         BT848_INT_RISCI | BT848_INT_OCERR |
1185                         BT848_INT_FMTCHG|BT848_INT_HLOCK|
1186                         BT848_INT_I2CDONE,
1187                         BT848_INT_MASK);
1188         }
1189 }
1190
1191 static void init_bt848(struct bttv *btv)
1192 {
1193         if (bttv_tvcards[btv->c.type].no_video) {
1194                 /* very basic init only */
1195                 init_irqreg(btv);
1196                 return;
1197         }
1198
1199         btwrite(0x00, BT848_CAP_CTL);
1200         btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1201         btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1202
1203         /* set planar and packed mode trigger points and         */
1204         /* set rising edge of inverted GPINTR pin as irq trigger */
1205         btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1206                 BT848_GPIO_DMA_CTL_PLTP1_16|
1207                 BT848_GPIO_DMA_CTL_PLTP23_16|
1208                 BT848_GPIO_DMA_CTL_GPINTC|
1209                 BT848_GPIO_DMA_CTL_GPINTI,
1210                 BT848_GPIO_DMA_CTL);
1211
1212         btwrite(0x20, BT848_E_VSCALE_HI);
1213         btwrite(0x20, BT848_O_VSCALE_HI);
1214
1215         v4l2_ctrl_handler_setup(&btv->ctrl_handler);
1216
1217         /* interrupt */
1218         init_irqreg(btv);
1219 }
1220
1221 static void bttv_reinit_bt848(struct bttv *btv)
1222 {
1223         unsigned long flags;
1224
1225         if (bttv_verbose)
1226                 pr_info("%d: reset, reinitialize\n", btv->c.nr);
1227         spin_lock_irqsave(&btv->s_lock,flags);
1228         btv->errors=0;
1229         bttv_set_dma(btv,0);
1230         spin_unlock_irqrestore(&btv->s_lock,flags);
1231
1232         init_bt848(btv);
1233         btv->pll.pll_current = -1;
1234         set_input(btv, btv->input, btv->tvnorm);
1235 }
1236
1237 static int bttv_s_ctrl(struct v4l2_ctrl *c)
1238 {
1239         struct bttv *btv = container_of(c->handler, struct bttv, ctrl_handler);
1240         int val;
1241
1242         switch (c->id) {
1243         case V4L2_CID_BRIGHTNESS:
1244                 bt848_bright(btv, c->val);
1245                 break;
1246         case V4L2_CID_HUE:
1247                 bt848_hue(btv, c->val);
1248                 break;
1249         case V4L2_CID_CONTRAST:
1250                 bt848_contrast(btv, c->val);
1251                 break;
1252         case V4L2_CID_SATURATION:
1253                 bt848_sat(btv, c->val);
1254                 break;
1255         case V4L2_CID_COLOR_KILLER:
1256                 if (c->val) {
1257                         btor(BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1258                         btor(BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1259                 } else {
1260                         btand(~BT848_SCLOOP_CKILL, BT848_E_SCLOOP);
1261                         btand(~BT848_SCLOOP_CKILL, BT848_O_SCLOOP);
1262                 }
1263                 break;
1264         case V4L2_CID_AUDIO_MUTE:
1265                 audio_mute(btv, c->val);
1266                 btv->mute = c->val;
1267                 break;
1268         case V4L2_CID_AUDIO_VOLUME:
1269                 btv->volume_gpio(btv, c->val);
1270                 break;
1271
1272         case V4L2_CID_CHROMA_AGC:
1273                 val = c->val ? BT848_SCLOOP_CAGC : 0;
1274                 btwrite(val, BT848_E_SCLOOP);
1275                 btwrite(val, BT848_O_SCLOOP);
1276                 break;
1277         case V4L2_CID_PRIVATE_COMBFILTER:
1278                 btv->opt_combfilter = c->val;
1279                 break;
1280         case V4L2_CID_PRIVATE_LUMAFILTER:
1281                 if (c->val) {
1282                         btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1283                         btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1284                 } else {
1285                         btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1286                         btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1287                 }
1288                 break;
1289         case V4L2_CID_PRIVATE_AUTOMUTE:
1290                 btv->opt_automute = c->val;
1291                 break;
1292         case V4L2_CID_PRIVATE_AGC_CRUSH:
1293                 btwrite(BT848_ADC_RESERVED |
1294                                 (c->val ? BT848_ADC_CRUSH : 0),
1295                                 BT848_ADC);
1296                 break;
1297         case V4L2_CID_PRIVATE_VCR_HACK:
1298                 btv->opt_vcr_hack = c->val;
1299                 break;
1300         case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1301                 btwrite(c->val, BT848_WC_UP);
1302                 break;
1303         case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1304                 btwrite(c->val, BT848_WC_DOWN);
1305                 break;
1306         case V4L2_CID_PRIVATE_UV_RATIO:
1307                 btv->opt_uv_ratio = c->val;
1308                 bt848_sat(btv, btv->saturation);
1309                 break;
1310         case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1311                 btaor((c->val << 7), ~BT848_OFORM_RANGE, BT848_OFORM);
1312                 break;
1313         case V4L2_CID_PRIVATE_CORING:
1314                 btaor((c->val << 5), ~BT848_OFORM_CORE32, BT848_OFORM);
1315                 break;
1316         default:
1317                 return -EINVAL;
1318         }
1319         return 0;
1320 }
1321
1322 /* ----------------------------------------------------------------------- */
1323
1324 static const struct v4l2_ctrl_ops bttv_ctrl_ops = {
1325         .s_ctrl = bttv_s_ctrl,
1326 };
1327
1328 static struct v4l2_ctrl_config bttv_ctrl_combfilter = {
1329         .ops = &bttv_ctrl_ops,
1330         .id = V4L2_CID_PRIVATE_COMBFILTER,
1331         .name = "Comb Filter",
1332         .type = V4L2_CTRL_TYPE_BOOLEAN,
1333         .min = 0,
1334         .max = 1,
1335         .step = 1,
1336         .def = 1,
1337 };
1338
1339 static struct v4l2_ctrl_config bttv_ctrl_automute = {
1340         .ops = &bttv_ctrl_ops,
1341         .id = V4L2_CID_PRIVATE_AUTOMUTE,
1342         .name = "Auto Mute",
1343         .type = V4L2_CTRL_TYPE_BOOLEAN,
1344         .min = 0,
1345         .max = 1,
1346         .step = 1,
1347         .def = 1,
1348 };
1349
1350 static struct v4l2_ctrl_config bttv_ctrl_lumafilter = {
1351         .ops = &bttv_ctrl_ops,
1352         .id = V4L2_CID_PRIVATE_LUMAFILTER,
1353         .name = "Luma Decimation Filter",
1354         .type = V4L2_CTRL_TYPE_BOOLEAN,
1355         .min = 0,
1356         .max = 1,
1357         .step = 1,
1358         .def = 1,
1359 };
1360
1361 static struct v4l2_ctrl_config bttv_ctrl_agc_crush = {
1362         .ops = &bttv_ctrl_ops,
1363         .id = V4L2_CID_PRIVATE_AGC_CRUSH,
1364         .name = "AGC Crush",
1365         .type = V4L2_CTRL_TYPE_BOOLEAN,
1366         .min = 0,
1367         .max = 1,
1368         .step = 1,
1369         .def = 1,
1370 };
1371
1372 static struct v4l2_ctrl_config bttv_ctrl_vcr_hack = {
1373         .ops = &bttv_ctrl_ops,
1374         .id = V4L2_CID_PRIVATE_VCR_HACK,
1375         .name = "VCR Hack",
1376         .type = V4L2_CTRL_TYPE_BOOLEAN,
1377         .min = 0,
1378         .max = 1,
1379         .step = 1,
1380         .def = 1,
1381 };
1382
1383 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_lower = {
1384         .ops = &bttv_ctrl_ops,
1385         .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
1386         .name = "Whitecrush Lower",
1387         .type = V4L2_CTRL_TYPE_INTEGER,
1388         .min = 0,
1389         .max = 255,
1390         .step = 1,
1391         .def = 0x7f,
1392 };
1393
1394 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_upper = {
1395         .ops = &bttv_ctrl_ops,
1396         .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
1397         .name = "Whitecrush Upper",
1398         .type = V4L2_CTRL_TYPE_INTEGER,
1399         .min = 0,
1400         .max = 255,
1401         .step = 1,
1402         .def = 0xcf,
1403 };
1404
1405 static struct v4l2_ctrl_config bttv_ctrl_uv_ratio = {
1406         .ops = &bttv_ctrl_ops,
1407         .id = V4L2_CID_PRIVATE_UV_RATIO,
1408         .name = "UV Ratio",
1409         .type = V4L2_CTRL_TYPE_INTEGER,
1410         .min = 0,
1411         .max = 100,
1412         .step = 1,
1413         .def = 50,
1414 };
1415
1416 static struct v4l2_ctrl_config bttv_ctrl_full_luma = {
1417         .ops = &bttv_ctrl_ops,
1418         .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
1419         .name = "Full Luma Range",
1420         .type = V4L2_CTRL_TYPE_BOOLEAN,
1421         .min = 0,
1422         .max = 1,
1423         .step = 1,
1424 };
1425
1426 static struct v4l2_ctrl_config bttv_ctrl_coring = {
1427         .ops = &bttv_ctrl_ops,
1428         .id = V4L2_CID_PRIVATE_CORING,
1429         .name = "Coring",
1430         .type = V4L2_CTRL_TYPE_INTEGER,
1431         .min = 0,
1432         .max = 3,
1433         .step = 1,
1434 };
1435
1436
1437 /* ----------------------------------------------------------------------- */
1438
1439 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1440 {
1441         unsigned int outbits, data;
1442         outbits = btread(BT848_GPIO_OUT_EN);
1443         data    = btread(BT848_GPIO_DATA);
1444         pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1445                  btv->c.nr, outbits, data & outbits, data & ~outbits, comment);
1446 }
1447
1448 static const struct bttv_format*
1449 format_by_fourcc(int fourcc)
1450 {
1451         unsigned int i;
1452
1453         for (i = 0; i < FORMATS; i++) {
1454                 if (-1 == formats[i].fourcc)
1455                         continue;
1456                 if (formats[i].fourcc == fourcc)
1457                         return formats+i;
1458         }
1459         return NULL;
1460 }
1461
1462 /* ----------------------------------------------------------------------- */
1463 /* video4linux (1) interface                                               */
1464
1465 static int queue_setup(struct vb2_queue *q, unsigned int *num_buffers,
1466                        unsigned int *num_planes, unsigned int sizes[],
1467                        struct device *alloc_devs[])
1468 {
1469         struct bttv *btv = vb2_get_drv_priv(q);
1470         unsigned int size = btv->fmt->depth * btv->width * btv->height >> 3;
1471
1472         if (*num_planes)
1473                 return sizes[0] < size ? -EINVAL : 0;
1474         *num_planes = 1;
1475         sizes[0] = size;
1476
1477         return 0;
1478 }
1479
1480 static void buf_queue(struct vb2_buffer *vb)
1481 {
1482         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1483         struct vb2_queue *vq = vb->vb2_queue;
1484         struct bttv *btv = vb2_get_drv_priv(vq);
1485         struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
1486         unsigned long flags;
1487
1488         spin_lock_irqsave(&btv->s_lock, flags);
1489         if (list_empty(&btv->capture)) {
1490                 btv->loop_irq = BT848_RISC_VIDEO;
1491                 if (vb2_is_streaming(&btv->vbiq))
1492                         btv->loop_irq |= BT848_RISC_VBI;
1493                 bttv_set_dma(btv, BT848_CAP_CTL_CAPTURE_ODD |
1494                              BT848_CAP_CTL_CAPTURE_EVEN);
1495         }
1496         list_add_tail(&buf->list, &btv->capture);
1497         spin_unlock_irqrestore(&btv->s_lock, flags);
1498 }
1499
1500 static int buf_prepare(struct vb2_buffer *vb)
1501 {
1502         struct vb2_queue *vq = vb->vb2_queue;
1503         struct bttv *btv = vb2_get_drv_priv(vq);
1504         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1505         struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
1506         unsigned int size = (btv->fmt->depth * btv->width * btv->height) >> 3;
1507
1508         if (vb2_plane_size(vb, 0) < size)
1509                 return -EINVAL;
1510         vb2_set_plane_payload(vb, 0, size);
1511
1512         if (btv->field != V4L2_FIELD_ALTERNATE) {
1513                 buf->vbuf.field = btv->field;
1514         } else if (btv->field_last == V4L2_FIELD_TOP) {
1515                 buf->vbuf.field = V4L2_FIELD_BOTTOM;
1516                 btv->field_last = V4L2_FIELD_BOTTOM;
1517         } else {
1518                 buf->vbuf.field = V4L2_FIELD_TOP;
1519                 btv->field_last = V4L2_FIELD_TOP;
1520         }
1521
1522         /* Allocate memory for risc struct and create the risc program. */
1523         return bttv_buffer_risc(btv, buf);
1524 }
1525
1526 static void buf_cleanup(struct vb2_buffer *vb)
1527 {
1528         struct vb2_queue *vq = vb->vb2_queue;
1529         struct bttv *btv = vb2_get_drv_priv(vq);
1530         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1531         struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf);
1532
1533         btcx_riscmem_free(btv->c.pci, &buf->top);
1534         btcx_riscmem_free(btv->c.pci, &buf->bottom);
1535 }
1536
1537 static int start_streaming(struct vb2_queue *q, unsigned int count)
1538 {
1539         int seqnr = 0;
1540         struct bttv_buffer *buf;
1541         struct bttv *btv = vb2_get_drv_priv(q);
1542
1543         if (!check_alloc_btres_lock(btv, RESOURCE_VIDEO_STREAM)) {
1544                 if (btv->field_count)
1545                         seqnr++;
1546                 while (!list_empty(&btv->capture)) {
1547                         buf = list_entry(btv->capture.next,
1548                                          struct bttv_buffer, list);
1549                         list_del(&buf->list);
1550                         buf->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
1551                         vb2_buffer_done(&buf->vbuf.vb2_buf,
1552                                         VB2_BUF_STATE_QUEUED);
1553                 }
1554                 return -EBUSY;
1555         }
1556         if (!vb2_is_streaming(&btv->vbiq)) {
1557                 init_irqreg(btv);
1558                 btv->field_count = 0;
1559         }
1560         btv->framedrop = 0;
1561
1562         return 0;
1563 }
1564
1565 static void stop_streaming(struct vb2_queue *q)
1566 {
1567         unsigned long flags;
1568         struct bttv *btv = vb2_get_drv_priv(q);
1569
1570         vb2_wait_for_all_buffers(q);
1571         spin_lock_irqsave(&btv->s_lock, flags);
1572         free_btres_lock(btv, RESOURCE_VIDEO_STREAM);
1573         if (!vb2_is_streaming(&btv->vbiq)) {
1574                 /* stop field counter */
1575                 btand(~BT848_INT_VSYNC, BT848_INT_MASK);
1576         }
1577         spin_unlock_irqrestore(&btv->s_lock, flags);
1578 }
1579
1580 static const struct vb2_ops bttv_video_qops = {
1581         .queue_setup    = queue_setup,
1582         .buf_queue      = buf_queue,
1583         .buf_prepare    = buf_prepare,
1584         .buf_cleanup    = buf_cleanup,
1585         .start_streaming = start_streaming,
1586         .stop_streaming = stop_streaming,
1587         .wait_prepare   = vb2_ops_wait_prepare,
1588         .wait_finish    = vb2_ops_wait_finish,
1589 };
1590
1591 static void radio_enable(struct bttv *btv)
1592 {
1593         /* Switch to the radio tuner */
1594         if (!btv->has_radio_tuner) {
1595                 btv->has_radio_tuner = 1;
1596                 bttv_call_all(btv, tuner, s_radio);
1597                 btv->audio_input = TVAUDIO_INPUT_RADIO;
1598                 audio_input(btv, btv->audio_input);
1599         }
1600 }
1601
1602 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id)
1603 {
1604         struct bttv *btv = video_drvdata(file);
1605         unsigned int i;
1606
1607         for (i = 0; i < BTTV_TVNORMS; i++)
1608                 if (id & bttv_tvnorms[i].v4l2_id)
1609                         break;
1610         if (i == BTTV_TVNORMS)
1611                 return -EINVAL;
1612         btv->std = id;
1613         set_tvnorm(btv, i);
1614         return 0;
1615 }
1616
1617 static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id)
1618 {
1619         struct bttv *btv = video_drvdata(file);
1620
1621         *id = btv->std;
1622         return 0;
1623 }
1624
1625 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1626 {
1627         struct bttv *btv = video_drvdata(file);
1628
1629         if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1630                 *id &= V4L2_STD_625_50;
1631         else
1632                 *id &= V4L2_STD_525_60;
1633         return 0;
1634 }
1635
1636 static int bttv_enum_input(struct file *file, void *priv,
1637                                         struct v4l2_input *i)
1638 {
1639         struct bttv *btv = video_drvdata(file);
1640
1641         if (i->index >= bttv_tvcards[btv->c.type].video_inputs)
1642                 return -EINVAL;
1643
1644         i->type     = V4L2_INPUT_TYPE_CAMERA;
1645         i->audioset = 0;
1646
1647         if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1648                 sprintf(i->name, "Television");
1649                 i->type  = V4L2_INPUT_TYPE_TUNER;
1650                 i->tuner = 0;
1651         } else if (i->index == btv->svhs) {
1652                 sprintf(i->name, "S-Video");
1653         } else {
1654                 sprintf(i->name, "Composite%d", i->index);
1655         }
1656
1657         if (i->index == btv->input) {
1658                 __u32 dstatus = btread(BT848_DSTATUS);
1659                 if (0 == (dstatus & BT848_DSTATUS_PRES))
1660                         i->status |= V4L2_IN_ST_NO_SIGNAL;
1661                 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1662                         i->status |= V4L2_IN_ST_NO_H_LOCK;
1663         }
1664
1665         i->std = BTTV_NORMS;
1666         return 0;
1667 }
1668
1669 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1670 {
1671         struct bttv *btv = video_drvdata(file);
1672
1673         *i = btv->input;
1674
1675         return 0;
1676 }
1677
1678 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1679 {
1680         struct bttv *btv = video_drvdata(file);
1681
1682         if (i >= bttv_tvcards[btv->c.type].video_inputs)
1683                 return -EINVAL;
1684
1685         set_input(btv, i, btv->tvnorm);
1686         return 0;
1687 }
1688
1689 static int bttv_s_tuner(struct file *file, void *priv,
1690                                         const struct v4l2_tuner *t)
1691 {
1692         struct bttv *btv = video_drvdata(file);
1693
1694         if (t->index)
1695                 return -EINVAL;
1696
1697         bttv_call_all(btv, tuner, s_tuner, t);
1698
1699         if (btv->audio_mode_gpio) {
1700                 struct v4l2_tuner copy = *t;
1701
1702                 btv->audio_mode_gpio(btv, &copy, 1);
1703         }
1704         return 0;
1705 }
1706
1707 static int bttv_g_frequency(struct file *file, void *priv,
1708                                         struct v4l2_frequency *f)
1709 {
1710         struct bttv *btv = video_drvdata(file);
1711
1712         if (f->tuner)
1713                 return -EINVAL;
1714
1715         if (f->type == V4L2_TUNER_RADIO)
1716                 radio_enable(btv);
1717         f->frequency = f->type == V4L2_TUNER_RADIO ?
1718                                 btv->radio_freq : btv->tv_freq;
1719
1720         return 0;
1721 }
1722
1723 static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f)
1724 {
1725         struct v4l2_frequency new_freq = *f;
1726
1727         bttv_call_all(btv, tuner, s_frequency, f);
1728         /* s_frequency may clamp the frequency, so get the actual
1729            frequency before assigning radio/tv_freq. */
1730         bttv_call_all(btv, tuner, g_frequency, &new_freq);
1731         if (new_freq.type == V4L2_TUNER_RADIO) {
1732                 radio_enable(btv);
1733                 btv->radio_freq = new_freq.frequency;
1734                 if (btv->has_tea575x) {
1735                         btv->tea.freq = btv->radio_freq;
1736                         snd_tea575x_set_freq(&btv->tea);
1737                 }
1738         } else {
1739                 btv->tv_freq = new_freq.frequency;
1740         }
1741 }
1742
1743 static int bttv_s_frequency(struct file *file, void *priv,
1744                                         const struct v4l2_frequency *f)
1745 {
1746         struct bttv *btv = video_drvdata(file);
1747
1748         if (f->tuner)
1749                 return -EINVAL;
1750
1751         bttv_set_frequency(btv, f);
1752         return 0;
1753 }
1754
1755 static int bttv_log_status(struct file *file, void *f)
1756 {
1757         struct video_device *vdev = video_devdata(file);
1758         struct bttv *btv = video_drvdata(file);
1759
1760         v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name);
1761         bttv_call_all(btv, core, log_status);
1762         return 0;
1763 }
1764
1765 #ifdef CONFIG_VIDEO_ADV_DEBUG
1766 static int bttv_g_register(struct file *file, void *f,
1767                                         struct v4l2_dbg_register *reg)
1768 {
1769         struct bttv *btv = video_drvdata(file);
1770
1771         /* bt848 has a 12-bit register space */
1772         reg->reg &= 0xfff;
1773         reg->val = btread(reg->reg);
1774         reg->size = 1;
1775
1776         return 0;
1777 }
1778
1779 static int bttv_s_register(struct file *file, void *f,
1780                                         const struct v4l2_dbg_register *reg)
1781 {
1782         struct bttv *btv = video_drvdata(file);
1783
1784         /* bt848 has a 12-bit register space */
1785         btwrite(reg->val, reg->reg & 0xfff);
1786
1787         return 0;
1788 }
1789 #endif
1790
1791 /* Given cropping boundaries b and the scaled width and height of a
1792    single field or frame, which must not exceed hardware limits, this
1793    function adjusts the cropping parameters c. */
1794 static void
1795 bttv_crop_adjust        (struct bttv_crop *             c,
1796                          const struct v4l2_rect *       b,
1797                          __s32                          width,
1798                          __s32                          height,
1799                          enum v4l2_field                field)
1800 {
1801         __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
1802         __s32 max_left;
1803         __s32 max_top;
1804
1805         if (width < c->min_scaled_width) {
1806                 /* Max. hor. scale factor 16:1. */
1807                 c->rect.width = width * 16;
1808         } else if (width > c->max_scaled_width) {
1809                 /* Min. hor. scale factor 1:1. */
1810                 c->rect.width = width;
1811
1812                 max_left = b->left + b->width - width;
1813                 max_left = min(max_left, (__s32) MAX_HDELAY);
1814                 if (c->rect.left > max_left)
1815                         c->rect.left = max_left;
1816         }
1817
1818         if (height < c->min_scaled_height) {
1819                 /* Max. vert. scale factor 16:1, single fields 8:1. */
1820                 c->rect.height = height * 16;
1821         } else if (frame_height > c->max_scaled_height) {
1822                 /* Min. vert. scale factor 1:1.
1823                    Top and height count field lines times two. */
1824                 c->rect.height = (frame_height + 1) & ~1;
1825
1826                 max_top = b->top + b->height - c->rect.height;
1827                 if (c->rect.top > max_top)
1828                         c->rect.top = max_top;
1829         }
1830
1831         bttv_crop_calc_limits(c);
1832 }
1833
1834 /* Returns an error if scaling to a frame or single field with the given
1835    width and height is not possible with the current cropping parameters
1836    and width aligned according to width_mask. If adjust_size is TRUE the
1837    function may adjust the width and/or height instead, rounding width
1838    to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
1839    also adjust the current cropping parameters to get closer to the
1840    desired image size. */
1841 static int
1842 limit_scaled_size_lock(struct bttv *btv, __s32 *width, __s32 *height,
1843                        enum v4l2_field field, unsigned int width_mask,
1844                        unsigned int width_bias, int adjust_size,
1845                        int adjust_crop)
1846 {
1847         const struct v4l2_rect *b;
1848         struct bttv_crop *c;
1849         __s32 min_width;
1850         __s32 min_height;
1851         __s32 max_width;
1852         __s32 max_height;
1853         int rc;
1854
1855         WARN_ON((int)width_mask >= 0 ||
1856                 width_bias >= (unsigned int)(-width_mask));
1857
1858         /* Make sure tvnorm, vbi_end and the current cropping parameters
1859            remain consistent until we're done. */
1860
1861         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
1862
1863         /* Do crop - use current, don't - use default parameters. */
1864         c = &btv->crop[!!btv->do_crop];
1865
1866         if (btv->do_crop
1867             && adjust_size
1868             && adjust_crop
1869             && !locked_btres(btv, VIDEO_RESOURCES)) {
1870                 min_width = 48;
1871                 min_height = 32;
1872
1873                 /* We cannot scale up. When the scaled image is larger
1874                    than crop.rect we adjust the crop.rect as required
1875                    by the V4L2 spec, hence cropcap.bounds are our limit. */
1876                 max_width = min_t(unsigned int, b->width, MAX_HACTIVE);
1877                 max_height = b->height;
1878
1879                 /* We cannot capture the same line as video and VBI data.
1880                    Note btv->vbi_end is really a minimum, see
1881                    bttv_vbi_try_fmt(). */
1882                 if (btv->vbi_end > b->top) {
1883                         max_height -= btv->vbi_end - b->top;
1884                         rc = -EBUSY;
1885                         if (min_height > max_height)
1886                                 goto fail;
1887                 }
1888         } else {
1889                 rc = -EBUSY;
1890                 if (btv->vbi_end > c->rect.top)
1891                         goto fail;
1892
1893                 min_width  = c->min_scaled_width;
1894                 min_height = c->min_scaled_height;
1895                 max_width  = c->max_scaled_width;
1896                 max_height = c->max_scaled_height;
1897
1898                 adjust_crop = 0;
1899         }
1900
1901         min_width = (min_width - width_mask - 1) & width_mask;
1902         max_width = max_width & width_mask;
1903
1904         /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
1905         /* Min. scale factor is 1:1. */
1906         max_height >>= !V4L2_FIELD_HAS_BOTH(field);
1907
1908         if (adjust_size) {
1909                 *width = clamp(*width, min_width, max_width);
1910                 *height = clamp(*height, min_height, max_height);
1911
1912                 /* Round after clamping to avoid overflow. */
1913                 *width = (*width + width_bias) & width_mask;
1914
1915                 if (adjust_crop) {
1916                         bttv_crop_adjust(c, b, *width, *height, field);
1917
1918                         if (btv->vbi_end > c->rect.top) {
1919                                 /* Move the crop window out of the way. */
1920                                 c->rect.top = btv->vbi_end;
1921                         }
1922                 }
1923         } else {
1924                 rc = -EINVAL;
1925                 if (*width  < min_width ||
1926                     *height < min_height ||
1927                     *width  > max_width ||
1928                     *height > max_height ||
1929                     0 != (*width & ~width_mask))
1930                         goto fail;
1931         }
1932
1933         rc = 0; /* success */
1934
1935  fail:
1936
1937         return rc;
1938 }
1939
1940 static int bttv_switch_type(struct bttv *btv, enum v4l2_buf_type type)
1941 {
1942         int res;
1943         struct vb2_queue *q;
1944
1945         switch (type) {
1946         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1947                 q = &btv->capq;
1948                 res = RESOURCE_VIDEO_STREAM;
1949                 break;
1950         case V4L2_BUF_TYPE_VBI_CAPTURE:
1951                 q = &btv->vbiq;
1952                 res = RESOURCE_VBI;
1953                 break;
1954         default:
1955                 WARN_ON(1);
1956                 return -EINVAL;
1957         }
1958
1959         if (check_btres(btv, res))
1960                 return -EBUSY;
1961         if (vb2_is_busy(q))
1962                 return -EBUSY;
1963         btv->type = type;
1964
1965         return 0;
1966 }
1967
1968 static void
1969 pix_format_set_size     (struct v4l2_pix_format *       f,
1970                          const struct bttv_format *     fmt,
1971                          unsigned int                   width,
1972                          unsigned int                   height)
1973 {
1974         f->width = width;
1975         f->height = height;
1976
1977         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
1978                 f->bytesperline = width; /* Y plane */
1979                 f->sizeimage = (width * height * fmt->depth) >> 3;
1980         } else {
1981                 f->bytesperline = (width * fmt->depth) >> 3;
1982                 f->sizeimage = height * f->bytesperline;
1983         }
1984 }
1985
1986 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
1987                                         struct v4l2_format *f)
1988 {
1989         struct bttv *btv = video_drvdata(file);
1990
1991         pix_format_set_size(&f->fmt.pix, btv->fmt, btv->width, btv->height);
1992         f->fmt.pix.field = btv->field;
1993         f->fmt.pix.pixelformat  = btv->fmt->fourcc;
1994         f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
1995
1996         return 0;
1997 }
1998
1999 static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt,
2000                                         unsigned int *width_mask,
2001                                         unsigned int *width_bias)
2002 {
2003         if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2004                 *width_mask = ~15; /* width must be a multiple of 16 pixels */
2005                 *width_bias = 8;   /* nearest */
2006         } else {
2007                 *width_mask = ~3; /* width must be a multiple of 4 pixels */
2008                 *width_bias = 2;  /* nearest */
2009         }
2010 }
2011
2012 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2013                                                 struct v4l2_format *f)
2014 {
2015         const struct bttv_format *fmt;
2016         struct bttv *btv = video_drvdata(file);
2017         enum v4l2_field field;
2018         __s32 width, height;
2019         __s32 height2;
2020         unsigned int width_mask, width_bias;
2021         int rc;
2022
2023         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2024         if (NULL == fmt)
2025                 return -EINVAL;
2026
2027         field = f->fmt.pix.field;
2028
2029         switch (field) {
2030         case V4L2_FIELD_TOP:
2031         case V4L2_FIELD_BOTTOM:
2032         case V4L2_FIELD_ALTERNATE:
2033         case V4L2_FIELD_INTERLACED:
2034                 break;
2035         case V4L2_FIELD_SEQ_BT:
2036         case V4L2_FIELD_SEQ_TB:
2037                 if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) {
2038                         field = V4L2_FIELD_SEQ_TB;
2039                         break;
2040                 }
2041                 fallthrough;
2042         default: /* FIELD_ANY case */
2043                 height2 = btv->crop[!!btv->do_crop].rect.height >> 1;
2044                 field = (f->fmt.pix.height > height2)
2045                         ? V4L2_FIELD_INTERLACED
2046                         : V4L2_FIELD_BOTTOM;
2047                 break;
2048         }
2049
2050         width = f->fmt.pix.width;
2051         height = f->fmt.pix.height;
2052
2053         bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2054         rc = limit_scaled_size_lock(btv, &width, &height, field, width_mask,
2055                                     width_bias, 1, 0);
2056         if (0 != rc)
2057                 return rc;
2058
2059         /* update data for the application */
2060         f->fmt.pix.field = field;
2061         pix_format_set_size(&f->fmt.pix, fmt, width, height);
2062         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2063
2064         return 0;
2065 }
2066
2067 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2068                               struct v4l2_format *f)
2069 {
2070         int retval;
2071         const struct bttv_format *fmt;
2072         struct bttv *btv = video_drvdata(file);
2073         __s32 width, height;
2074         unsigned int width_mask, width_bias;
2075         enum v4l2_field field;
2076
2077         retval = bttv_switch_type(btv, f->type);
2078         if (0 != retval)
2079                 return retval;
2080
2081         retval = bttv_try_fmt_vid_cap(file, priv, f);
2082         if (0 != retval)
2083                 return retval;
2084
2085         width = f->fmt.pix.width;
2086         height = f->fmt.pix.height;
2087         field = f->fmt.pix.field;
2088
2089         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2090         bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias);
2091         retval = limit_scaled_size_lock(btv, &width, &height, f->fmt.pix.field,
2092                                         width_mask, width_bias, 1, 1);
2093         if (0 != retval)
2094                 return retval;
2095
2096         f->fmt.pix.field = field;
2097
2098         /* update our state information */
2099         btv->fmt = fmt;
2100         btv->width = f->fmt.pix.width;
2101         btv->height = f->fmt.pix.height;
2102         btv->field = f->fmt.pix.field;
2103         /*
2104          * When field is V4L2_FIELD_ALTERNATE, buffers will be either
2105          * V4L2_FIELD_TOP or V4L2_FIELD_BOTTOM depending on the value of
2106          * field_last. Initialize field_last to V4L2_FIELD_BOTTOM so that
2107          * streaming starts with a V4L2_FIELD_TOP buffer.
2108          */
2109         btv->field_last = V4L2_FIELD_BOTTOM;
2110
2111         return 0;
2112 }
2113
2114 static int bttv_querycap(struct file *file, void  *priv,
2115                                 struct v4l2_capability *cap)
2116 {
2117         struct bttv *btv = video_drvdata(file);
2118
2119         if (0 == v4l2)
2120                 return -EINVAL;
2121
2122         strscpy(cap->driver, "bttv", sizeof(cap->driver));
2123         strscpy(cap->card, btv->video_dev.name, sizeof(cap->card));
2124         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
2125                             V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
2126         if (video_is_registered(&btv->vbi_dev))
2127                 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
2128         if (video_is_registered(&btv->radio_dev)) {
2129                 cap->capabilities |= V4L2_CAP_RADIO;
2130                 if (btv->has_tea575x)
2131                         cap->capabilities |= V4L2_CAP_HW_FREQ_SEEK;
2132         }
2133
2134         /*
2135          * No need to lock here: those vars are initialized during board
2136          * probe and remains untouched during the rest of the driver lifecycle
2137          */
2138         if (btv->has_saa6588)
2139                 cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2140         if (btv->tuner_type != TUNER_ABSENT)
2141                 cap->capabilities |= V4L2_CAP_TUNER;
2142         return 0;
2143 }
2144
2145 static int bttv_enum_fmt_vid_cap(struct file *file, void  *priv,
2146                                  struct v4l2_fmtdesc *f)
2147 {
2148         int index = -1, i;
2149
2150         for (i = 0; i < FORMATS; i++) {
2151                 if (formats[i].fourcc != -1)
2152                         index++;
2153                 if ((unsigned int)index == f->index)
2154                         break;
2155         }
2156         if (FORMATS == i)
2157                 return -EINVAL;
2158
2159         f->pixelformat = formats[i].fourcc;
2160
2161         return 0;
2162 }
2163
2164 static int bttv_g_parm(struct file *file, void *f,
2165                                 struct v4l2_streamparm *parm)
2166 {
2167         struct bttv *btv = video_drvdata(file);
2168
2169         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2170                 return -EINVAL;
2171         parm->parm.capture.readbuffers = gbuffers;
2172         v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2173                                     &parm->parm.capture.timeperframe);
2174
2175         return 0;
2176 }
2177
2178 static int bttv_g_tuner(struct file *file, void *priv,
2179                                 struct v4l2_tuner *t)
2180 {
2181         struct bttv *btv = video_drvdata(file);
2182
2183         if (0 != t->index)
2184                 return -EINVAL;
2185
2186         t->rxsubchans = V4L2_TUNER_SUB_MONO;
2187         t->capability = V4L2_TUNER_CAP_NORM;
2188         bttv_call_all(btv, tuner, g_tuner, t);
2189         strscpy(t->name, "Television", sizeof(t->name));
2190         t->type       = V4L2_TUNER_ANALOG_TV;
2191         if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2192                 t->signal = 0xffff;
2193
2194         if (btv->audio_mode_gpio)
2195                 btv->audio_mode_gpio(btv, t, 0);
2196
2197         return 0;
2198 }
2199
2200 static int bttv_g_pixelaspect(struct file *file, void *priv,
2201                               int type, struct v4l2_fract *f)
2202 {
2203         struct bttv *btv = video_drvdata(file);
2204
2205         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2206                 return -EINVAL;
2207
2208         /* defrect and bounds are set via g_selection */
2209         *f = bttv_tvnorms[btv->tvnorm].cropcap.pixelaspect;
2210         return 0;
2211 }
2212
2213 static int bttv_g_selection(struct file *file, void *f, struct v4l2_selection *sel)
2214 {
2215         struct bttv *btv = video_drvdata(file);
2216
2217         if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2218                 return -EINVAL;
2219
2220         switch (sel->target) {
2221         case V4L2_SEL_TGT_CROP:
2222                 sel->r = btv->crop[!!btv->do_crop].rect;
2223                 break;
2224         case V4L2_SEL_TGT_CROP_DEFAULT:
2225                 sel->r = bttv_tvnorms[btv->tvnorm].cropcap.defrect;
2226                 break;
2227         case V4L2_SEL_TGT_CROP_BOUNDS:
2228                 sel->r = bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2229                 break;
2230         default:
2231                 return -EINVAL;
2232         }
2233
2234         return 0;
2235 }
2236
2237 static int bttv_s_selection(struct file *file, void *f, struct v4l2_selection *sel)
2238 {
2239         struct bttv *btv = video_drvdata(file);
2240         const struct v4l2_rect *b;
2241         int retval;
2242         struct bttv_crop c;
2243         __s32 b_left;
2244         __s32 b_top;
2245         __s32 b_right;
2246         __s32 b_bottom;
2247
2248         if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2249                 return -EINVAL;
2250
2251         if (sel->target != V4L2_SEL_TGT_CROP)
2252                 return -EINVAL;
2253
2254         /* Make sure tvnorm, vbi_end and the current cropping
2255            parameters remain consistent until we're done. Note
2256            read() may change vbi_end in check_alloc_btres_lock(). */
2257         retval = -EBUSY;
2258
2259         if (locked_btres(btv, VIDEO_RESOURCES))
2260                 return retval;
2261
2262         b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2263
2264         b_left = b->left;
2265         b_right = b_left + b->width;
2266         b_bottom = b->top + b->height;
2267
2268         b_top = max(b->top, btv->vbi_end);
2269         if (b_top + 32 >= b_bottom) {
2270                 return retval;
2271         }
2272
2273         /* Min. scaled size 48 x 32. */
2274         c.rect.left = clamp_t(s32, sel->r.left, b_left, b_right - 48);
2275         c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
2276
2277         c.rect.width = clamp_t(s32, sel->r.width,
2278                              48, b_right - c.rect.left);
2279
2280         c.rect.top = clamp_t(s32, sel->r.top, b_top, b_bottom - 32);
2281         /* Top and height must be a multiple of two. */
2282         c.rect.top = (c.rect.top + 1) & ~1;
2283
2284         c.rect.height = clamp_t(s32, sel->r.height,
2285                               32, b_bottom - c.rect.top);
2286         c.rect.height = (c.rect.height + 1) & ~1;
2287
2288         bttv_crop_calc_limits(&c);
2289
2290         sel->r = c.rect;
2291
2292         btv->crop[1] = c;
2293
2294         btv->do_crop = 1;
2295
2296         if (btv->width < c.min_scaled_width)
2297                 btv->width = c.min_scaled_width;
2298         else if (btv->width > c.max_scaled_width)
2299                 btv->width = c.max_scaled_width;
2300
2301         if (btv->height < c.min_scaled_height)
2302                 btv->height = c.min_scaled_height;
2303         else if (btv->height > c.max_scaled_height)
2304                 btv->height = c.max_scaled_height;
2305
2306         return 0;
2307 }
2308
2309 static const struct v4l2_file_operations bttv_fops =
2310 {
2311         .owner            = THIS_MODULE,
2312         .open             = v4l2_fh_open,
2313         .release          = vb2_fop_release,
2314         .unlocked_ioctl   = video_ioctl2,
2315         .read             = vb2_fop_read,
2316         .mmap             = vb2_fop_mmap,
2317         .poll             = vb2_fop_poll,
2318 };
2319
2320 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
2321         .vidioc_querycap                = bttv_querycap,
2322         .vidioc_enum_fmt_vid_cap        = bttv_enum_fmt_vid_cap,
2323         .vidioc_g_fmt_vid_cap           = bttv_g_fmt_vid_cap,
2324         .vidioc_try_fmt_vid_cap         = bttv_try_fmt_vid_cap,
2325         .vidioc_s_fmt_vid_cap           = bttv_s_fmt_vid_cap,
2326         .vidioc_g_fmt_vbi_cap           = bttv_g_fmt_vbi_cap,
2327         .vidioc_try_fmt_vbi_cap         = bttv_try_fmt_vbi_cap,
2328         .vidioc_s_fmt_vbi_cap           = bttv_s_fmt_vbi_cap,
2329         .vidioc_g_pixelaspect           = bttv_g_pixelaspect,
2330         .vidioc_reqbufs                 = vb2_ioctl_reqbufs,
2331         .vidioc_create_bufs             = vb2_ioctl_create_bufs,
2332         .vidioc_querybuf                = vb2_ioctl_querybuf,
2333         .vidioc_qbuf                    = vb2_ioctl_qbuf,
2334         .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
2335         .vidioc_streamon                = vb2_ioctl_streamon,
2336         .vidioc_streamoff               = vb2_ioctl_streamoff,
2337         .vidioc_s_std                   = bttv_s_std,
2338         .vidioc_g_std                   = bttv_g_std,
2339         .vidioc_enum_input              = bttv_enum_input,
2340         .vidioc_g_input                 = bttv_g_input,
2341         .vidioc_s_input                 = bttv_s_input,
2342         .vidioc_g_tuner                 = bttv_g_tuner,
2343         .vidioc_s_tuner                 = bttv_s_tuner,
2344         .vidioc_g_selection             = bttv_g_selection,
2345         .vidioc_s_selection             = bttv_s_selection,
2346         .vidioc_g_parm                  = bttv_g_parm,
2347         .vidioc_g_frequency             = bttv_g_frequency,
2348         .vidioc_s_frequency             = bttv_s_frequency,
2349         .vidioc_log_status              = bttv_log_status,
2350         .vidioc_querystd                = bttv_querystd,
2351         .vidioc_subscribe_event         = v4l2_ctrl_subscribe_event,
2352         .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
2353 #ifdef CONFIG_VIDEO_ADV_DEBUG
2354         .vidioc_g_register              = bttv_g_register,
2355         .vidioc_s_register              = bttv_s_register,
2356 #endif
2357 };
2358
2359 static struct video_device bttv_video_template = {
2360         .fops         = &bttv_fops,
2361         .ioctl_ops    = &bttv_ioctl_ops,
2362         .tvnorms      = BTTV_NORMS,
2363 };
2364
2365 /* ----------------------------------------------------------------------- */
2366 /* radio interface                                                         */
2367
2368 static int radio_open(struct file *file)
2369 {
2370         struct video_device *vdev = video_devdata(file);
2371         struct bttv *btv = video_drvdata(file);
2372         int ret = v4l2_fh_open(file);
2373
2374         if (ret)
2375                 return ret;
2376
2377         dprintk("open dev=%s\n", video_device_node_name(vdev));
2378         dprintk("%d: open called (radio)\n", btv->c.nr);
2379
2380         btv->radio_user++;
2381         audio_mute(btv, btv->mute);
2382
2383         return 0;
2384 }
2385
2386 static int radio_release(struct file *file)
2387 {
2388         struct bttv *btv = video_drvdata(file);
2389         struct saa6588_command cmd;
2390
2391         btv->radio_user--;
2392
2393         bttv_call_all(btv, core, command, SAA6588_CMD_CLOSE, &cmd);
2394
2395         if (btv->radio_user == 0)
2396                 btv->has_radio_tuner = 0;
2397
2398         v4l2_fh_release(file);
2399
2400         return 0;
2401 }
2402
2403 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
2404 {
2405         struct bttv *btv = video_drvdata(file);
2406
2407         if (0 != t->index)
2408                 return -EINVAL;
2409         strscpy(t->name, "Radio", sizeof(t->name));
2410         t->type = V4L2_TUNER_RADIO;
2411         radio_enable(btv);
2412
2413         bttv_call_all(btv, tuner, g_tuner, t);
2414
2415         if (btv->audio_mode_gpio)
2416                 btv->audio_mode_gpio(btv, t, 0);
2417
2418         if (btv->has_tea575x)
2419                 return snd_tea575x_g_tuner(&btv->tea, t);
2420
2421         return 0;
2422 }
2423
2424 static int radio_s_tuner(struct file *file, void *priv,
2425                                         const struct v4l2_tuner *t)
2426 {
2427         struct bttv *btv = video_drvdata(file);
2428
2429         if (0 != t->index)
2430                 return -EINVAL;
2431
2432         radio_enable(btv);
2433         bttv_call_all(btv, tuner, s_tuner, t);
2434         return 0;
2435 }
2436
2437 static int radio_s_hw_freq_seek(struct file *file, void *priv,
2438                                         const struct v4l2_hw_freq_seek *a)
2439 {
2440         struct bttv *btv = video_drvdata(file);
2441
2442         if (btv->has_tea575x)
2443                 return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a);
2444
2445         return -ENOTTY;
2446 }
2447
2448 static int radio_enum_freq_bands(struct file *file, void *priv,
2449                                          struct v4l2_frequency_band *band)
2450 {
2451         struct bttv *btv = video_drvdata(file);
2452
2453         if (btv->has_tea575x)
2454                 return snd_tea575x_enum_freq_bands(&btv->tea, band);
2455
2456         return -ENOTTY;
2457 }
2458
2459 static ssize_t radio_read(struct file *file, char __user *data,
2460                          size_t count, loff_t *ppos)
2461 {
2462         struct bttv *btv = video_drvdata(file);
2463         struct saa6588_command cmd;
2464
2465         cmd.block_count = count / 3;
2466         cmd.nonblocking = file->f_flags & O_NONBLOCK;
2467         cmd.buffer = data;
2468         cmd.instance = file;
2469         cmd.result = -ENODEV;
2470         radio_enable(btv);
2471
2472         bttv_call_all(btv, core, command, SAA6588_CMD_READ, &cmd);
2473
2474         return cmd.result;
2475 }
2476
2477 static __poll_t radio_poll(struct file *file, poll_table *wait)
2478 {
2479         struct bttv *btv = video_drvdata(file);
2480         struct saa6588_command cmd;
2481         __poll_t rc = v4l2_ctrl_poll(file, wait);
2482
2483         radio_enable(btv);
2484         cmd.instance = file;
2485         cmd.event_list = wait;
2486         cmd.poll_mask = 0;
2487         bttv_call_all(btv, core, command, SAA6588_CMD_POLL, &cmd);
2488
2489         return rc | cmd.poll_mask;
2490 }
2491
2492 static const struct v4l2_file_operations radio_fops =
2493 {
2494         .owner    = THIS_MODULE,
2495         .open     = radio_open,
2496         .read     = radio_read,
2497         .release  = radio_release,
2498         .unlocked_ioctl = video_ioctl2,
2499         .poll     = radio_poll,
2500 };
2501
2502 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2503         .vidioc_querycap        = bttv_querycap,
2504         .vidioc_log_status      = bttv_log_status,
2505         .vidioc_g_tuner         = radio_g_tuner,
2506         .vidioc_s_tuner         = radio_s_tuner,
2507         .vidioc_g_frequency     = bttv_g_frequency,
2508         .vidioc_s_frequency     = bttv_s_frequency,
2509         .vidioc_s_hw_freq_seek  = radio_s_hw_freq_seek,
2510         .vidioc_enum_freq_bands = radio_enum_freq_bands,
2511         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2512         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2513 };
2514
2515 static struct video_device radio_template = {
2516         .fops      = &radio_fops,
2517         .ioctl_ops = &radio_ioctl_ops,
2518 };
2519
2520 /* ----------------------------------------------------------------------- */
2521 /* some debug code                                                         */
2522
2523 static int bttv_risc_decode(u32 risc)
2524 {
2525         static char *instr[16] = {
2526                 [ BT848_RISC_WRITE     >> 28 ] = "write",
2527                 [ BT848_RISC_SKIP      >> 28 ] = "skip",
2528                 [ BT848_RISC_WRITEC    >> 28 ] = "writec",
2529                 [ BT848_RISC_JUMP      >> 28 ] = "jump",
2530                 [ BT848_RISC_SYNC      >> 28 ] = "sync",
2531                 [ BT848_RISC_WRITE123  >> 28 ] = "write123",
2532                 [ BT848_RISC_SKIP123   >> 28 ] = "skip123",
2533                 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
2534         };
2535         static int incr[16] = {
2536                 [ BT848_RISC_WRITE     >> 28 ] = 2,
2537                 [ BT848_RISC_JUMP      >> 28 ] = 2,
2538                 [ BT848_RISC_SYNC      >> 28 ] = 2,
2539                 [ BT848_RISC_WRITE123  >> 28 ] = 5,
2540                 [ BT848_RISC_SKIP123   >> 28 ] = 2,
2541                 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
2542         };
2543         static char *bits[] = {
2544                 "be0",  "be1",  "be2",  "be3/resync",
2545                 "set0", "set1", "set2", "set3",
2546                 "clr0", "clr1", "clr2", "clr3",
2547                 "irq",  "res",  "eol",  "sol",
2548         };
2549         int i;
2550
2551         pr_cont("0x%08x [ %s", risc,
2552                instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
2553         for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
2554                 if (risc & (1 << (i + 12)))
2555                         pr_cont(" %s", bits[i]);
2556         pr_cont(" count=%d ]\n", risc & 0xfff);
2557         return incr[risc >> 28] ? incr[risc >> 28] : 1;
2558 }
2559
2560 static void bttv_risc_disasm(struct bttv *btv,
2561                              struct btcx_riscmem *risc)
2562 {
2563         unsigned int i,j,n;
2564
2565         pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
2566                 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
2567         for (i = 0; i < (risc->size >> 2); i += n) {
2568                 pr_info("%s:   0x%lx: ",
2569                         btv->c.v4l2_dev.name,
2570                         (unsigned long)(risc->dma + (i<<2)));
2571                 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
2572                 for (j = 1; j < n; j++)
2573                         pr_info("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
2574                                 btv->c.v4l2_dev.name,
2575                                 (unsigned long)(risc->dma + ((i+j)<<2)),
2576                                 risc->cpu[i+j], j);
2577                 if (0 == risc->cpu[i])
2578                         break;
2579         }
2580 }
2581
2582 static void bttv_print_riscaddr(struct bttv *btv)
2583 {
2584         pr_info("  main: %08llx\n", (unsigned long long)btv->main.dma);
2585         pr_info("  vbi : o=%08llx e=%08llx\n",
2586                 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
2587                 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
2588         pr_info("  cap : o=%08llx e=%08llx\n",
2589                 btv->curr.top
2590                 ? (unsigned long long)btv->curr.top->top.dma : 0,
2591                 btv->curr.bottom
2592                 ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
2593         bttv_risc_disasm(btv, &btv->main);
2594 }
2595
2596 /* ----------------------------------------------------------------------- */
2597 /* irq handler                                                             */
2598
2599 static char *irq_name[] = {
2600         "FMTCHG",  // format change detected (525 vs. 625)
2601         "VSYNC",   // vertical sync (new field)
2602         "HSYNC",   // horizontal sync
2603         "OFLOW",   // chroma/luma AGC overflow
2604         "HLOCK",   // horizontal lock changed
2605         "VPRES",   // video presence changed
2606         "6", "7",
2607         "I2CDONE", // hw irc operation finished
2608         "GPINT",   // gpio port triggered irq
2609         "10",
2610         "RISCI",   // risc instruction triggered irq
2611         "FBUS",    // pixel data fifo dropped data (high pci bus latencies)
2612         "FTRGT",   // pixel data fifo overrun
2613         "FDSR",    // fifo data stream resyncronisation
2614         "PPERR",   // parity error (data transfer)
2615         "RIPERR",  // parity error (read risc instructions)
2616         "PABORT",  // pci abort
2617         "OCERR",   // risc instruction error
2618         "SCERR",   // syncronisation error
2619 };
2620
2621 static void bttv_print_irqbits(u32 print, u32 mark)
2622 {
2623         unsigned int i;
2624
2625         pr_cont("bits:");
2626         for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
2627                 if (print & (1 << i))
2628                         pr_cont(" %s", irq_name[i]);
2629                 if (mark & (1 << i))
2630                         pr_cont("*");
2631         }
2632 }
2633
2634 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
2635 {
2636         pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
2637                 btv->c.nr,
2638                 (unsigned long)btv->main.dma,
2639                 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
2640                 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
2641                 (unsigned long)rc);
2642
2643         if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
2644                 pr_notice("%d: Oh, there (temporarily?) is no input signal. Ok, then this is harmless, don't worry ;)\n",
2645                           btv->c.nr);
2646                 return;
2647         }
2648         pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n",
2649                   btv->c.nr);
2650         pr_notice("%d: Lets try to catch the culprit red-handed ...\n",
2651                   btv->c.nr);
2652         dump_stack();
2653 }
2654
2655 static int
2656 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
2657 {
2658         struct bttv_buffer *item;
2659
2660         memset(set,0,sizeof(*set));
2661
2662         /* capture request ? */
2663         if (!list_empty(&btv->capture)) {
2664                 set->frame_irq = BT848_RISC_VIDEO;
2665                 item = list_entry(btv->capture.next, struct bttv_buffer, list);
2666
2667                 if (V4L2_FIELD_HAS_TOP(item->vbuf.field))
2668                         set->top    = item;
2669                 if (V4L2_FIELD_HAS_BOTTOM(item->vbuf.field))
2670                         set->bottom = item;
2671
2672                 /* capture request for other field ? */
2673                 if (!V4L2_FIELD_HAS_BOTH(item->vbuf.field) &&
2674                     item->list.next != &btv->capture) {
2675                         item = list_entry(item->list.next,
2676                                           struct bttv_buffer, list);
2677                         /* Mike Isely <isely@pobox.com> - Only check
2678                          * and set up the bottom field in the logic
2679                          * below.  Don't ever do the top field.  This
2680                          * of course means that if we set up the
2681                          * bottom field in the above code that we'll
2682                          * actually skip a field.  But that's OK.
2683                          * Having processed only a single buffer this
2684                          * time, then the next time around the first
2685                          * available buffer should be for a top field.
2686                          * That will then cause us here to set up a
2687                          * top then a bottom field in the normal way.
2688                          * The alternative to this understanding is
2689                          * that we set up the second available buffer
2690                          * as a top field, but that's out of order
2691                          * since this driver always processes the top
2692                          * field first - the effect will be the two
2693                          * buffers being returned in the wrong order,
2694                          * with the second buffer also being delayed
2695                          * by one field time (owing to the fifo nature
2696                          * of videobuf).  Worse still, we'll be stuck
2697                          * doing fields out of order now every time
2698                          * until something else causes a field to be
2699                          * dropped.  By effectively forcing a field to
2700                          * drop this way then we always get back into
2701                          * sync within a single frame time.  (Out of
2702                          * order fields can screw up deinterlacing
2703                          * algorithms.) */
2704                         if (!V4L2_FIELD_HAS_BOTH(item->vbuf.field)) {
2705                                 if (!set->bottom &&
2706                                     item->vbuf.field == V4L2_FIELD_BOTTOM)
2707                                         set->bottom = item;
2708                                 if (set->top && set->bottom) {
2709                                         /*
2710                                          * The buffer set has a top buffer and
2711                                          * a bottom buffer and they are not
2712                                          * copies of each other.
2713                                          */
2714                                         set->top_irq = BT848_RISC_TOP;
2715                                 }
2716                         }
2717                 }
2718         }
2719
2720         dprintk("%d: next set: top=%p bottom=%p [irq=%d,%d]\n",
2721                 btv->c.nr, set->top, set->bottom,
2722                 set->frame_irq, set->top_irq);
2723         return 0;
2724 }
2725
2726 static void
2727 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
2728                       struct bttv_buffer_set *curr, unsigned int state)
2729 {
2730         u64 ts = ktime_get_ns();
2731
2732         if (wakeup->top == wakeup->bottom) {
2733                 if (NULL != wakeup->top && curr->top != wakeup->top) {
2734                         if (irq_debug > 1)
2735                                 pr_debug("%d: wakeup: both=%p\n",
2736                                          btv->c.nr, wakeup->top);
2737                         wakeup->top->vbuf.vb2_buf.timestamp = ts;
2738                         wakeup->top->vbuf.sequence = btv->field_count >> 1;
2739                         vb2_buffer_done(&wakeup->top->vbuf.vb2_buf, state);
2740                         if (btv->field_count == 0)
2741                                 btor(BT848_INT_VSYNC, BT848_INT_MASK);
2742                 }
2743         } else {
2744                 if (NULL != wakeup->top && curr->top != wakeup->top) {
2745                         if (irq_debug > 1)
2746                                 pr_debug("%d: wakeup: top=%p\n",
2747                                          btv->c.nr, wakeup->top);
2748                         wakeup->top->vbuf.vb2_buf.timestamp = ts;
2749                         wakeup->top->vbuf.sequence = btv->field_count >> 1;
2750                         vb2_buffer_done(&wakeup->top->vbuf.vb2_buf, state);
2751                         if (btv->field_count == 0)
2752                                 btor(BT848_INT_VSYNC, BT848_INT_MASK);
2753                 }
2754                 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
2755                         if (irq_debug > 1)
2756                                 pr_debug("%d: wakeup: bottom=%p\n",
2757                                          btv->c.nr, wakeup->bottom);
2758                         wakeup->bottom->vbuf.vb2_buf.timestamp = ts;
2759                         wakeup->bottom->vbuf.sequence = btv->field_count >> 1;
2760                         vb2_buffer_done(&wakeup->bottom->vbuf.vb2_buf, state);
2761                         if (btv->field_count == 0)
2762                                 btor(BT848_INT_VSYNC, BT848_INT_MASK);
2763                 }
2764         }
2765 }
2766
2767 static void
2768 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
2769                                 unsigned int state)
2770 {
2771         if (NULL == wakeup)
2772                 return;
2773         wakeup->vbuf.vb2_buf.timestamp = ktime_get_ns();
2774         wakeup->vbuf.sequence = btv->field_count >> 1;
2775
2776         /*
2777          * Ugly hack for backwards compatibility.
2778          * Some applications expect that the last 4 bytes of
2779          * the VBI data contains the sequence number.
2780          *
2781          * This makes it possible to associate the VBI data
2782          * with the video frame if you use read() to get the
2783          * VBI data.
2784          */
2785         if (vb2_fileio_is_active(wakeup->vbuf.vb2_buf.vb2_queue)) {
2786                 u32 *vaddr = vb2_plane_vaddr(&wakeup->vbuf.vb2_buf, 0);
2787                 unsigned long size =
2788                         vb2_get_plane_payload(&wakeup->vbuf.vb2_buf, 0) / 4;
2789
2790                 if (vaddr && size) {
2791                         vaddr += size - 1;
2792                         *vaddr = wakeup->vbuf.sequence;
2793                 }
2794         }
2795
2796         vb2_buffer_done(&wakeup->vbuf.vb2_buf, state);
2797         if (btv->field_count == 0)
2798                 btor(BT848_INT_VSYNC, BT848_INT_MASK);
2799 }
2800
2801 static void bttv_irq_timeout(struct timer_list *t)
2802 {
2803         struct bttv *btv = from_timer(btv, t, timeout);
2804         struct bttv_buffer_set old,new;
2805         struct bttv_buffer *ovbi;
2806         struct bttv_buffer *item;
2807         unsigned long flags;
2808         int seqnr = 0;
2809
2810         if (bttv_verbose) {
2811                 pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
2812                         btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
2813                         btread(BT848_RISC_COUNT));
2814                 bttv_print_irqbits(btread(BT848_INT_STAT),0);
2815                 pr_cont("\n");
2816         }
2817
2818         spin_lock_irqsave(&btv->s_lock,flags);
2819
2820         /* deactivate stuff */
2821         memset(&new,0,sizeof(new));
2822         old  = btv->curr;
2823         ovbi = btv->cvbi;
2824         btv->curr = new;
2825         btv->cvbi = NULL;
2826         btv->loop_irq = 0;
2827         bttv_buffer_activate_video(btv, &new);
2828         bttv_buffer_activate_vbi(btv,   NULL);
2829         bttv_set_dma(btv, 0);
2830
2831         /* wake up */
2832         bttv_irq_wakeup_video(btv, &old, &new, VB2_BUF_STATE_DONE);
2833         bttv_irq_wakeup_vbi(btv, ovbi, VB2_BUF_STATE_DONE);
2834
2835         /* cancel all outstanding capture / vbi requests */
2836         if (btv->field_count)
2837                 seqnr++;
2838         while (!list_empty(&btv->capture)) {
2839                 item = list_entry(btv->capture.next, struct bttv_buffer, list);
2840                 list_del(&item->list);
2841                 item->vbuf.vb2_buf.timestamp = ktime_get_ns();
2842                 item->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
2843                 vb2_buffer_done(&item->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
2844         }
2845         while (!list_empty(&btv->vcapture)) {
2846                 item = list_entry(btv->vcapture.next, struct bttv_buffer, list);
2847                 list_del(&item->list);
2848                 item->vbuf.vb2_buf.timestamp = ktime_get_ns();
2849                 item->vbuf.sequence = (btv->field_count >> 1) + seqnr++;
2850                 vb2_buffer_done(&item->vbuf.vb2_buf, VB2_BUF_STATE_ERROR);
2851         }
2852
2853         btv->errors++;
2854         spin_unlock_irqrestore(&btv->s_lock,flags);
2855 }
2856
2857 static void
2858 bttv_irq_wakeup_top(struct bttv *btv)
2859 {
2860         struct bttv_buffer *wakeup = btv->curr.top;
2861
2862         if (NULL == wakeup)
2863                 return;
2864
2865         spin_lock(&btv->s_lock);
2866         btv->curr.top_irq = 0;
2867         btv->curr.top = NULL;
2868         bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
2869         wakeup->vbuf.vb2_buf.timestamp = ktime_get_ns();
2870         wakeup->vbuf.sequence = btv->field_count >> 1;
2871         vb2_buffer_done(&wakeup->vbuf.vb2_buf, VB2_BUF_STATE_DONE);
2872         if (btv->field_count == 0)
2873                 btor(BT848_INT_VSYNC, BT848_INT_MASK);
2874         spin_unlock(&btv->s_lock);
2875 }
2876
2877 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
2878 {
2879         if (rc < risc->dma)
2880                 return 0;
2881         if (rc > risc->dma + risc->size)
2882                 return 0;
2883         return 1;
2884 }
2885
2886 static void
2887 bttv_irq_switch_video(struct bttv *btv)
2888 {
2889         struct bttv_buffer_set new;
2890         struct bttv_buffer_set old;
2891         dma_addr_t rc;
2892
2893         spin_lock(&btv->s_lock);
2894
2895         /* new buffer set */
2896         bttv_irq_next_video(btv, &new);
2897         rc = btread(BT848_RISC_COUNT);
2898         if ((btv->curr.top    && is_active(&btv->curr.top->top,       rc)) ||
2899             (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
2900                 btv->framedrop++;
2901                 if (debug_latency)
2902                         bttv_irq_debug_low_latency(btv, rc);
2903                 spin_unlock(&btv->s_lock);
2904                 return;
2905         }
2906
2907         /* switch over */
2908         old = btv->curr;
2909         btv->curr = new;
2910         btv->loop_irq &= ~BT848_RISC_VIDEO;
2911         bttv_buffer_activate_video(btv, &new);
2912         bttv_set_dma(btv, 0);
2913
2914         /* switch input */
2915         if (UNSET != btv->new_input) {
2916                 video_mux(btv,btv->new_input);
2917                 btv->new_input = UNSET;
2918         }
2919
2920         /* wake up finished buffers */
2921         bttv_irq_wakeup_video(btv, &old, &new, VB2_BUF_STATE_DONE);
2922         spin_unlock(&btv->s_lock);
2923 }
2924
2925 static void
2926 bttv_irq_switch_vbi(struct bttv *btv)
2927 {
2928         struct bttv_buffer *new = NULL;
2929         struct bttv_buffer *old;
2930         u32 rc;
2931
2932         spin_lock(&btv->s_lock);
2933
2934         if (!list_empty(&btv->vcapture))
2935                 new = list_entry(btv->vcapture.next, struct bttv_buffer, list);
2936         old = btv->cvbi;
2937
2938         rc = btread(BT848_RISC_COUNT);
2939         if (NULL != old && (is_active(&old->top,    rc) ||
2940                             is_active(&old->bottom, rc))) {
2941                 btv->framedrop++;
2942                 if (debug_latency)
2943                         bttv_irq_debug_low_latency(btv, rc);
2944                 spin_unlock(&btv->s_lock);
2945                 return;
2946         }
2947
2948         /* switch */
2949         btv->cvbi = new;
2950         btv->loop_irq &= ~BT848_RISC_VBI;
2951         bttv_buffer_activate_vbi(btv, new);
2952         bttv_set_dma(btv, 0);
2953
2954         bttv_irq_wakeup_vbi(btv, old, VB2_BUF_STATE_DONE);
2955         spin_unlock(&btv->s_lock);
2956 }
2957
2958 static irqreturn_t bttv_irq(int irq, void *dev_id)
2959 {
2960         u32 stat,astat;
2961         u32 dstat;
2962         int count;
2963         struct bttv *btv;
2964         int handled = 0;
2965
2966         btv=(struct bttv *)dev_id;
2967
2968         count=0;
2969         while (1) {
2970                 /* get/clear interrupt status bits */
2971                 stat=btread(BT848_INT_STAT);
2972                 astat=stat&btread(BT848_INT_MASK);
2973                 if (!astat)
2974                         break;
2975                 handled = 1;
2976                 btwrite(stat,BT848_INT_STAT);
2977
2978                 /* get device status bits */
2979                 dstat=btread(BT848_DSTATUS);
2980
2981                 if (irq_debug) {
2982                         pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ",
2983                                  btv->c.nr, count, btv->field_count,
2984                                  stat>>28, btread(BT848_RISC_COUNT));
2985                         bttv_print_irqbits(stat,astat);
2986                         if (stat & BT848_INT_HLOCK)
2987                                 pr_cont("   HLOC => %s",
2988                                         dstat & BT848_DSTATUS_HLOC
2989                                         ? "yes" : "no");
2990                         if (stat & BT848_INT_VPRES)
2991                                 pr_cont("   PRES => %s",
2992                                         dstat & BT848_DSTATUS_PRES
2993                                         ? "yes" : "no");
2994                         if (stat & BT848_INT_FMTCHG)
2995                                 pr_cont("   NUML => %s",
2996                                         dstat & BT848_DSTATUS_NUML
2997                                         ? "625" : "525");
2998                         pr_cont("\n");
2999                 }
3000
3001                 if (astat&BT848_INT_VSYNC)
3002                         btv->field_count++;
3003
3004                 if ((astat & BT848_INT_GPINT) && btv->remote) {
3005                         bttv_input_irq(btv);
3006                 }
3007
3008                 if (astat & BT848_INT_I2CDONE) {
3009                         btv->i2c_done = stat;
3010                         wake_up(&btv->i2c_queue);
3011                 }
3012
3013                 if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_VBI))
3014                         bttv_irq_switch_vbi(btv);
3015
3016                 if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_TOP))
3017                         bttv_irq_wakeup_top(btv);
3018
3019                 if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_VIDEO))
3020                         bttv_irq_switch_video(btv);
3021
3022                 if ((astat & BT848_INT_HLOCK)  &&  btv->opt_automute)
3023                         /* trigger automute */
3024                         audio_mux_gpio(btv, btv->audio_input, btv->mute);
3025
3026                 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3027                         pr_info("%d: %s%s @ %08x,",
3028                                 btv->c.nr,
3029                                 (astat & BT848_INT_SCERR) ? "SCERR" : "",
3030                                 (astat & BT848_INT_OCERR) ? "OCERR" : "",
3031                                 btread(BT848_RISC_COUNT));
3032                         bttv_print_irqbits(stat,astat);
3033                         pr_cont("\n");
3034                         if (bttv_debug)
3035                                 bttv_print_riscaddr(btv);
3036                 }
3037                 if (fdsr && astat & BT848_INT_FDSR) {
3038                         pr_info("%d: FDSR @ %08x\n",
3039                                 btv->c.nr, btread(BT848_RISC_COUNT));
3040                         if (bttv_debug)
3041                                 bttv_print_riscaddr(btv);
3042                 }
3043
3044                 count++;
3045                 if (count > 4) {
3046
3047                         if (count > 8 || !(astat & BT848_INT_GPINT)) {
3048                                 btwrite(0, BT848_INT_MASK);
3049
3050                                 pr_err("%d: IRQ lockup, cleared int mask [",
3051                                        btv->c.nr);
3052                         } else {
3053                                 pr_err("%d: IRQ lockup, clearing GPINT from int mask [",
3054                                        btv->c.nr);
3055
3056                                 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3057                                                 BT848_INT_MASK);
3058                         }
3059
3060                         bttv_print_irqbits(stat,astat);
3061
3062                         pr_cont("]\n");
3063                 }
3064         }
3065         btv->irq_total++;
3066         if (handled)
3067                 btv->irq_me++;
3068         return IRQ_RETVAL(handled);
3069 }
3070
3071
3072 /* ----------------------------------------------------------------------- */
3073 /* initialization                                                          */
3074
3075 static int vdev_init(struct bttv *btv, struct video_device *vfd,
3076                      const struct video_device *template,
3077                      const char *type_name)
3078 {
3079         int err;
3080         struct vb2_queue *q;
3081         *vfd = *template;
3082         vfd->v4l2_dev = &btv->c.v4l2_dev;
3083         vfd->release = video_device_release_empty;
3084         video_set_drvdata(vfd, btv);
3085         snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3086                  btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3087                  type_name, bttv_tvcards[btv->c.type].name);
3088         if (btv->tuner_type == TUNER_ABSENT) {
3089                 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY);
3090                 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY);
3091                 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
3092                 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
3093         }
3094
3095         if (strcmp(type_name, "radio") == 0)
3096                 return 0;
3097
3098         if (strcmp(type_name, "video") == 0) {
3099                 q = &btv->capq;
3100                 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3101                 q->ops = &bttv_video_qops;
3102         } else if (strcmp(type_name, "vbi") == 0) {
3103                 q = &btv->vbiq;
3104                 q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
3105                 q->ops = &bttv_vbi_qops;
3106         } else {
3107                 return -EINVAL;
3108         }
3109         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
3110         q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ | VB2_DMABUF;
3111         q->mem_ops = &vb2_dma_sg_memops;
3112         q->drv_priv = btv;
3113         q->gfp_flags = __GFP_DMA32;
3114         q->buf_struct_size = sizeof(struct bttv_buffer);
3115         q->lock = &btv->lock;
3116         q->min_buffers_needed = 2;
3117         q->dev = &btv->c.pci->dev;
3118         err = vb2_queue_init(q);
3119         if (err)
3120                 return err;
3121         vfd->queue = q;
3122
3123         return 0;
3124 }
3125
3126 static void bttv_unregister_video(struct bttv *btv)
3127 {
3128         video_unregister_device(&btv->video_dev);
3129         video_unregister_device(&btv->vbi_dev);
3130         video_unregister_device(&btv->radio_dev);
3131 }
3132
3133 /* register video4linux devices */
3134 static int bttv_register_video(struct bttv *btv)
3135 {
3136         /* video */
3137         vdev_init(btv, &btv->video_dev, &bttv_video_template, "video");
3138         btv->video_dev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
3139                                      V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
3140         if (btv->tuner_type != TUNER_ABSENT)
3141                 btv->video_dev.device_caps |= V4L2_CAP_TUNER;
3142
3143         if (video_register_device(&btv->video_dev, VFL_TYPE_VIDEO,
3144                                   video_nr[btv->c.nr]) < 0)
3145                 goto err;
3146         pr_info("%d: registered device %s\n",
3147                 btv->c.nr, video_device_node_name(&btv->video_dev));
3148         if (device_create_file(&btv->video_dev.dev,
3149                                      &dev_attr_card)<0) {
3150                 pr_err("%d: device_create_file 'card' failed\n", btv->c.nr);
3151                 goto err;
3152         }
3153
3154         /* vbi */
3155         vdev_init(btv, &btv->vbi_dev, &bttv_video_template, "vbi");
3156         btv->vbi_dev.device_caps = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE |
3157                                    V4L2_CAP_STREAMING;
3158         if (btv->tuner_type != TUNER_ABSENT)
3159                 btv->vbi_dev.device_caps |= V4L2_CAP_TUNER;
3160
3161         if (video_register_device(&btv->vbi_dev, VFL_TYPE_VBI,
3162                                   vbi_nr[btv->c.nr]) < 0)
3163                 goto err;
3164         pr_info("%d: registered device %s\n",
3165                 btv->c.nr, video_device_node_name(&btv->vbi_dev));
3166
3167         if (!btv->has_radio)
3168                 return 0;
3169         /* radio */
3170         vdev_init(btv, &btv->radio_dev, &radio_template, "radio");
3171         btv->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
3172         if (btv->has_saa6588)
3173                 btv->radio_dev.device_caps |= V4L2_CAP_READWRITE |
3174                                               V4L2_CAP_RDS_CAPTURE;
3175         if (btv->has_tea575x)
3176                 btv->radio_dev.device_caps |= V4L2_CAP_HW_FREQ_SEEK;
3177         btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler;
3178         if (video_register_device(&btv->radio_dev, VFL_TYPE_RADIO,
3179                                   radio_nr[btv->c.nr]) < 0)
3180                 goto err;
3181         pr_info("%d: registered device %s\n",
3182                 btv->c.nr, video_device_node_name(&btv->radio_dev));
3183
3184         /* all done */
3185         return 0;
3186
3187  err:
3188         bttv_unregister_video(btv);
3189         return -1;
3190 }
3191
3192
3193 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3194 /* response on cards with no firmware is not enabled by OF */
3195 static void pci_set_command(struct pci_dev *dev)
3196 {
3197 #if defined(__powerpc__)
3198         unsigned int cmd;
3199
3200         pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3201         cmd = (cmd | PCI_COMMAND_MEMORY );
3202         pci_write_config_dword(dev, PCI_COMMAND, cmd);
3203 #endif
3204 }
3205
3206 static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
3207 {
3208         struct v4l2_frequency init_freq = {
3209                 .tuner = 0,
3210                 .type = V4L2_TUNER_ANALOG_TV,
3211                 .frequency = 980,
3212         };
3213         int result;
3214         unsigned char lat;
3215         struct bttv *btv;
3216         struct v4l2_ctrl_handler *hdl;
3217
3218         if (bttv_num == BTTV_MAX)
3219                 return -ENOMEM;
3220         pr_info("Bt8xx card found (%d)\n", bttv_num);
3221         bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
3222         if (btv == NULL) {
3223                 pr_err("out of memory\n");
3224                 return -ENOMEM;
3225         }
3226         btv->c.nr  = bttv_num;
3227         snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
3228                         "bttv%d", btv->c.nr);
3229
3230         /* initialize structs / fill in defaults */
3231         mutex_init(&btv->lock);
3232         spin_lock_init(&btv->s_lock);
3233         spin_lock_init(&btv->gpio_lock);
3234         init_waitqueue_head(&btv->i2c_queue);
3235         INIT_LIST_HEAD(&btv->c.subs);
3236         INIT_LIST_HEAD(&btv->capture);
3237         INIT_LIST_HEAD(&btv->vcapture);
3238
3239         timer_setup(&btv->timeout, bttv_irq_timeout, 0);
3240
3241         btv->i2c_rc = -1;
3242         btv->tuner_type  = UNSET;
3243         btv->new_input   = UNSET;
3244         btv->has_radio=radio[btv->c.nr];
3245
3246         /* pci stuff (init, get irq/mmio, ... */
3247         btv->c.pci = dev;
3248         btv->id  = dev->device;
3249         if (pci_enable_device(dev)) {
3250                 pr_warn("%d: Can't enable device\n", btv->c.nr);
3251                 result = -EIO;
3252                 goto free_mem;
3253         }
3254         if (dma_set_mask(&dev->dev, DMA_BIT_MASK(32))) {
3255                 pr_warn("%d: No suitable DMA available\n", btv->c.nr);
3256                 result = -EIO;
3257                 goto free_mem;
3258         }
3259         if (!request_mem_region(pci_resource_start(dev,0),
3260                                 pci_resource_len(dev,0),
3261                                 btv->c.v4l2_dev.name)) {
3262                 pr_warn("%d: can't request iomem (0x%llx)\n",
3263                         btv->c.nr,
3264                         (unsigned long long)pci_resource_start(dev, 0));
3265                 result = -EBUSY;
3266                 goto free_mem;
3267         }
3268         pci_set_master(dev);
3269         pci_set_command(dev);
3270
3271         result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
3272         if (result < 0) {
3273                 pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr);
3274                 goto fail0;
3275         }
3276         hdl = &btv->ctrl_handler;
3277         v4l2_ctrl_handler_init(hdl, 20);
3278         btv->c.v4l2_dev.ctrl_handler = hdl;
3279         v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6);
3280
3281         btv->revision = dev->revision;
3282         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
3283         pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n",
3284                 bttv_num, btv->id, btv->revision, pci_name(dev),
3285                 btv->c.pci->irq, lat,
3286                 (unsigned long long)pci_resource_start(dev, 0));
3287         schedule();
3288
3289         btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
3290         if (NULL == btv->bt848_mmio) {
3291                 pr_err("%d: ioremap() failed\n", btv->c.nr);
3292                 result = -EIO;
3293                 goto fail1;
3294         }
3295
3296         /* identify card */
3297         bttv_idcard(btv);
3298
3299         /* disable irqs, register irq handler */
3300         btwrite(0, BT848_INT_MASK);
3301         result = request_irq(btv->c.pci->irq, bttv_irq,
3302             IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv);
3303         if (result < 0) {
3304                 pr_err("%d: can't get IRQ %d\n",
3305                        bttv_num, btv->c.pci->irq);
3306                 goto fail1;
3307         }
3308
3309         if (0 != bttv_handle_chipset(btv)) {
3310                 result = -EIO;
3311                 goto fail2;
3312         }
3313
3314         /* init options from insmod args */
3315         btv->opt_combfilter = combfilter;
3316         bttv_ctrl_combfilter.def = combfilter;
3317         bttv_ctrl_lumafilter.def = lumafilter;
3318         btv->opt_automute   = automute;
3319         bttv_ctrl_automute.def = automute;
3320         bttv_ctrl_agc_crush.def = agc_crush;
3321         btv->opt_vcr_hack   = vcr_hack;
3322         bttv_ctrl_vcr_hack.def = vcr_hack;
3323         bttv_ctrl_whitecrush_upper.def = whitecrush_upper;
3324         bttv_ctrl_whitecrush_lower.def = whitecrush_lower;
3325         btv->opt_uv_ratio   = uv_ratio;
3326         bttv_ctrl_uv_ratio.def = uv_ratio;
3327         bttv_ctrl_full_luma.def = full_luma_range;
3328         bttv_ctrl_coring.def = coring;
3329
3330         /* fill struct bttv with some useful defaults */
3331         btv->fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
3332         btv->width = 320;
3333         btv->height = 240;
3334         btv->field = V4L2_FIELD_INTERLACED;
3335         btv->input = 0;
3336         btv->tvnorm = 0; /* Index into bttv_tvnorms[] i.e. PAL. */
3337         bttv_vbi_fmt_reset(&btv->vbi_fmt, btv->tvnorm);
3338         btv->vbi_count[0] = VBI_DEFLINES;
3339         btv->vbi_count[1] = VBI_DEFLINES;
3340         btv->do_crop = 0;
3341
3342         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3343                         V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768);
3344         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3345                         V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00);
3346         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3347                         V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768);
3348         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3349                         V4L2_CID_COLOR_KILLER, 0, 1, 1, 0);
3350         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3351                         V4L2_CID_HUE, 0, 0xff00, 0x100, 32768);
3352         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3353                         V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc);
3354         v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3355                 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
3356         if (btv->volume_gpio)
3357                 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops,
3358                         V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00);
3359         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL);
3360         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL);
3361         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL);
3362         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL);
3363         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL);
3364         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL);
3365         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL);
3366         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL);
3367         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL);
3368         v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL);
3369
3370         /* initialize hardware */
3371         if (bttv_gpio)
3372                 bttv_gpio_tracking(btv,"pre-init");
3373
3374         bttv_risc_init_main(btv);
3375         init_bt848(btv);
3376
3377         /* gpio */
3378         btwrite(0x00, BT848_GPIO_REG_INP);
3379         btwrite(0x00, BT848_GPIO_OUT_EN);
3380         if (bttv_verbose)
3381                 bttv_gpio_tracking(btv,"init");
3382
3383         /* needs to be done before i2c is registered */
3384         bttv_init_card1(btv);
3385
3386         /* register i2c + gpio */
3387         init_bttv_i2c(btv);
3388
3389         /* some card-specific stuff (needs working i2c) */
3390         bttv_init_card2(btv);
3391         bttv_init_tuner(btv);
3392         if (btv->tuner_type != TUNER_ABSENT) {
3393                 bttv_set_frequency(btv, &init_freq);
3394                 btv->radio_freq = 90500 * 16; /* 90.5Mhz default */
3395         }
3396         btv->std = V4L2_STD_PAL;
3397         init_irqreg(btv);
3398         if (!bttv_tvcards[btv->c.type].no_video)
3399                 v4l2_ctrl_handler_setup(hdl);
3400         if (hdl->error) {
3401                 result = hdl->error;
3402                 goto fail2;
3403         }
3404         /* mute device */
3405         audio_mute(btv, 1);
3406
3407         /* register video4linux + input */
3408         if (!bttv_tvcards[btv->c.type].no_video) {
3409                 v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl,
3410                                 v4l2_ctrl_radio_filter, false);
3411                 if (btv->radio_ctrl_handler.error) {
3412                         result = btv->radio_ctrl_handler.error;
3413                         goto fail2;
3414                 }
3415                 set_input(btv, btv->input, btv->tvnorm);
3416                 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
3417                 btv->crop[1] = btv->crop[0]; /* current = default */
3418                 disclaim_vbi_lines(btv);
3419                 disclaim_video_lines(btv);
3420                 bttv_register_video(btv);
3421         }
3422
3423         /* add subdevices and autoload dvb-bt8xx if needed */
3424         if (bttv_tvcards[btv->c.type].has_dvb) {
3425                 bttv_sub_add_device(&btv->c, "dvb");
3426                 request_modules(btv);
3427         }
3428
3429         if (!disable_ir) {
3430                 init_bttv_i2c_ir(btv);
3431                 bttv_input_init(btv);
3432         }
3433
3434         /* everything is fine */
3435         bttv_num++;
3436         return 0;
3437
3438 fail2:
3439         free_irq(btv->c.pci->irq,btv);
3440
3441 fail1:
3442         v4l2_ctrl_handler_free(&btv->ctrl_handler);
3443         v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
3444         v4l2_device_unregister(&btv->c.v4l2_dev);
3445
3446 fail0:
3447         if (btv->bt848_mmio)
3448                 iounmap(btv->bt848_mmio);
3449         release_mem_region(pci_resource_start(btv->c.pci,0),
3450                            pci_resource_len(btv->c.pci,0));
3451         pci_disable_device(btv->c.pci);
3452
3453 free_mem:
3454         bttvs[btv->c.nr] = NULL;
3455         kfree(btv);
3456         return result;
3457 }
3458
3459 static void bttv_remove(struct pci_dev *pci_dev)
3460 {
3461         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
3462         struct bttv *btv = to_bttv(v4l2_dev);
3463
3464         if (bttv_verbose)
3465                 pr_info("%d: unloading\n", btv->c.nr);
3466
3467         if (bttv_tvcards[btv->c.type].has_dvb)
3468                 flush_request_modules(btv);
3469
3470         /* shutdown everything (DMA+IRQs) */
3471         btand(~15, BT848_GPIO_DMA_CTL);
3472         btwrite(0, BT848_INT_MASK);
3473         btwrite(~0x0, BT848_INT_STAT);
3474         btwrite(0x0, BT848_GPIO_OUT_EN);
3475         if (bttv_gpio)
3476                 bttv_gpio_tracking(btv,"cleanup");
3477
3478         /* tell gpio modules we are leaving ... */
3479         btv->shutdown=1;
3480         bttv_input_fini(btv);
3481         bttv_sub_del_devices(&btv->c);
3482
3483         /* unregister i2c_bus + input */
3484         fini_bttv_i2c(btv);
3485
3486         /* unregister video4linux */
3487         bttv_unregister_video(btv);
3488
3489         /* free allocated memory */
3490         v4l2_ctrl_handler_free(&btv->ctrl_handler);
3491         v4l2_ctrl_handler_free(&btv->radio_ctrl_handler);
3492         btcx_riscmem_free(btv->c.pci,&btv->main);
3493
3494         /* free resources */
3495         free_irq(btv->c.pci->irq,btv);
3496         del_timer_sync(&btv->timeout);
3497         iounmap(btv->bt848_mmio);
3498         release_mem_region(pci_resource_start(btv->c.pci,0),
3499                            pci_resource_len(btv->c.pci,0));
3500         pci_disable_device(btv->c.pci);
3501
3502         v4l2_device_unregister(&btv->c.v4l2_dev);
3503         bttvs[btv->c.nr] = NULL;
3504         kfree(btv);
3505
3506         return;
3507 }
3508
3509 static int __maybe_unused bttv_suspend(struct device *dev)
3510 {
3511         struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
3512         struct bttv *btv = to_bttv(v4l2_dev);
3513         struct bttv_buffer_set idle;
3514         unsigned long flags;
3515
3516         dprintk("%d: suspend\n", btv->c.nr);
3517
3518         /* stop dma + irqs */
3519         spin_lock_irqsave(&btv->s_lock,flags);
3520         memset(&idle, 0, sizeof(idle));
3521         btv->state.video = btv->curr;
3522         btv->state.vbi   = btv->cvbi;
3523         btv->state.loop_irq = btv->loop_irq;
3524         btv->curr = idle;
3525         btv->loop_irq = 0;
3526         bttv_buffer_activate_video(btv, &idle);
3527         bttv_buffer_activate_vbi(btv, NULL);
3528         bttv_set_dma(btv, 0);
3529         btwrite(0, BT848_INT_MASK);
3530         spin_unlock_irqrestore(&btv->s_lock,flags);
3531
3532         /* save bt878 state */
3533         btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
3534         btv->state.gpio_data   = gpio_read();
3535
3536         btv->state.disabled = 1;
3537         return 0;
3538 }
3539
3540 static int __maybe_unused bttv_resume(struct device *dev)
3541 {
3542         struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
3543         struct bttv *btv = to_bttv(v4l2_dev);
3544         unsigned long flags;
3545
3546         dprintk("%d: resume\n", btv->c.nr);
3547
3548         btv->state.disabled = 0;
3549
3550         /* restore bt878 state */
3551         bttv_reinit_bt848(btv);
3552         gpio_inout(0xffffff, btv->state.gpio_enable);
3553         gpio_write(btv->state.gpio_data);
3554
3555         /* restart dma */
3556         spin_lock_irqsave(&btv->s_lock,flags);
3557         btv->curr = btv->state.video;
3558         btv->cvbi = btv->state.vbi;
3559         btv->loop_irq = btv->state.loop_irq;
3560         bttv_buffer_activate_video(btv, &btv->curr);
3561         bttv_buffer_activate_vbi(btv, btv->cvbi);
3562         bttv_set_dma(btv, 0);
3563         spin_unlock_irqrestore(&btv->s_lock,flags);
3564         return 0;
3565 }
3566
3567 static const struct pci_device_id bttv_pci_tbl[] = {
3568         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
3569         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
3570         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
3571         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
3572         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
3573         {0,}
3574 };
3575
3576 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
3577
3578 static SIMPLE_DEV_PM_OPS(bttv_pm_ops,
3579                          bttv_suspend,
3580                          bttv_resume);
3581
3582 static struct pci_driver bttv_pci_driver = {
3583         .name      = "bttv",
3584         .id_table  = bttv_pci_tbl,
3585         .probe     = bttv_probe,
3586         .remove    = bttv_remove,
3587         .driver.pm = &bttv_pm_ops,
3588 };
3589
3590 static int __init bttv_init_module(void)
3591 {
3592         int ret;
3593
3594         bttv_num = 0;
3595
3596         pr_info("driver version %s loaded\n", BTTV_VERSION);
3597         if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
3598                 gbuffers = 2;
3599         if (gbufsize > BTTV_MAX_FBUF)
3600                 gbufsize = BTTV_MAX_FBUF;
3601         gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
3602         if (bttv_verbose)
3603                 pr_info("using %d buffers with %dk (%d pages) each for capture\n",
3604                         gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
3605
3606         bttv_check_chipset();
3607
3608         ret = bus_register(&bttv_sub_bus_type);
3609         if (ret < 0) {
3610                 pr_warn("bus_register error: %d\n", ret);
3611                 return ret;
3612         }
3613         ret = pci_register_driver(&bttv_pci_driver);
3614         if (ret < 0)
3615                 bus_unregister(&bttv_sub_bus_type);
3616
3617         return ret;
3618 }
3619
3620 static void __exit bttv_cleanup_module(void)
3621 {
3622         pci_unregister_driver(&bttv_pci_driver);
3623         bus_unregister(&bttv_sub_bus_type);
3624 }
3625
3626 module_init(bttv_init_module);
3627 module_exit(bttv_cleanup_module);