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