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

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