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

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