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

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