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