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

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