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