err.no Git - linux-2.6/blob - drivers/media/video/bttv-driver.c

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