git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/bttv-driver.c

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