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