drivers/media/video/bttv-driver.c

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