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