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

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