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