SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/bttv-driver.c

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