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